STD Système C ++

Un système de fichiers conserve et classe les fichiers sur un moyen, souvent un ou plusieurs disques de stockage, d'une manière qui les rend accessibles pour la récupération. La plupart des systèmes de fichiers modernes gardent les fichiers organisés sous une forme en forme d'arbre (ou hiérarchique). Un ou plusieurs nœuds racine sont situés au sommet de l'arbre. Le système de fichiers est une bibliothèque de la norme C ++ 17 qui nous permet de travailler avec le chemin du fichier, les répertoires, l'état et les erreurs des fichiers dans un système de fichiers hiérarchique. Le boost.La bibliothèque de Système de fichiers sert de base à la création de cette bibliothèque standard. Avec cette bibliothèque, nous explorerons les différentes fonctions du système de fichiers et leurs performances en C ++ 17 et accéderons à leurs propriétés et recherchez. L'espace de noms STD :: Système de fichiers de Système propose la bibliothèque du système de fichiers. Nous utiliserons l'alias de l'espace de noms donné dans les exemples suivants dans tous les cas pour garder le code plus simple.

Exemple 1: Utilisation de STD :: Système de fichiers :: existe

Le système de fichiers std :: fournit la fonction qui est utilisée pour déterminer si un fichier ou un répertoire avec le chemin ou le statut spécifié existe déjà. Pour cela, nous implémentons un programme où nous importons le «système de fichiers» de la bibliothèque et créons une fonction vide «démo». Pour la fonction de démonstration, nous donnons le chemin d'accès et la fonction d'état du système de fichiers de classe. Ensuite, nous utilisons la condition IF-Else pour retourner la déclaration de l'existence du fichier.

À l'intérieur de la clause if, nous invoquons la fonction «FS :: Existe» et passons la variable «S» pour l'état du fichier et «PTH» pour le chemin du fichier. Si le statut de fichier existe et que le chemin du fichier existe, il imprime «Found». Et si le fichier n'existe pas, l'instruction «non trouvée» est imprimée. La fonction principale est implémentée avec le chemin du fichier et la création du répertoire.

Tout d'abord, nous spécifions le chemin du fichier. Ensuite, nous créons le répertoire et le lien symbolique pour le répertoire pour lier les deux fichiers. Toutes les fonctions que nous utilisons sont prises en charge par la bibliothèque Système de fichiers. Pour itérer sur les entrées de répertoire, nous utilisons la fonction Directory_iterator.

#inclure
#inclure
#inclure
#inclure
Espace de noms fs = std :: Système de fichiers;
void Demo (const fs :: path & pth, fs :: file_status s = fs :: file_status )

std :: cout << pth;
if (fs :: status_known (s) ? FS :: existe (s): FS :: existe (PTH))
std :: cout << " Found\n";
autre
std :: cout << "Not Found\n";

int main()

const fs :: path filebox "filebox";
fs :: create_directory (filebox);
std :: ofStream filebox / "file";
fs :: create_symLink ("Not exists", filebox / "symlink");
démo (filebox);
pour (const auto & entrée: fs :: répertoire_iterator (filebox))
démo (entrée, entrée.statut());
fs :: re Support_all (filebox);

Pour une compilation des fonctions et codes C ++ 17, nous utilisons les commandes suivantes. Par conséquent, nous pouvons voir l'existence du chemin du fichier et de l'état du fichier sur l'écran de sortie:

Exemple 2: Utilisation de STD :: Système de fichiers :: file_size

Le std :: fileSystem :: file_size est une fonction fournie par la bibliothèque de fichiers std :: de C de c++. Prenons l'exemple où le chemin du fichier est passé et l'objet associé est créé, ainsi que la taille du fichier à récupérer. Comme toutes les fonctions du système de fichiers sont prises en charge par la bibliothèque du système de fichiers, nous ajoutons la bibliothèque «» à notre programme. Ensuite, avec l'espace de noms, nous étiquetons le «système de fichiers STD ::» comme «FS».

Ensuite, nous utilisons la fonction FS :: Path et spécifions le chemin du fichier «Main.C ". Ensuite, nous appelons le std :: OfStream et passons l'objet de chemin de fichier à l'intérieur. De plus, nous utilisons la fonction put () qui prend le caractère «A» pour une utilisation normale. Après cela, nous récupérons la taille du fichier à l'aide de la fonction FileSystem :: file_size. Avec le système de fichiers :: Supprimer la fonction, nous supprimons le chemin du fichier. En fin de compte, nous avons un bloc d'essai pour attraper et lancer l'erreur si cela se produit.

#inclure
#inclure
#inclure
Espace de noms fs = std :: Système de fichiers;
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 :: retire (filepath);
essayer
fs :: file_size ("/ dev");
catch (fs :: filesystem_error & e)
std :: cout << e.what() << '\n';

Nous avons récupéré la taille du fichier en implémentant le programme avec le système de fichiers :: File_size Fonction. Nous avons obtenu l'erreur du système de fichiers de ne pas obtenir la taille du fichier.

Exemple 3: Utilisation de STD :: FileSystem :: FileSystem_error Fonction

Lorsque les surcharges de lancement des fonctions de la bibliothèque du système de fichiers échouent, un objet d'erreur spécifié par la classe std :: Système :: Erreur de système de fichiers est lancé. Nous utilisons le module d'erreur système qui gère l'erreur du programme. Nous identifions les chemins des fichiers inexistants dans le code suivant. Le bloc de capture prend le STD :: Système de fichiers :: Filesystem_error à l'intérieur pour lancer l'exception du système de fichiers.

Ici, nous utilisons les différents appels de fonction pour imprimer les exceptions pour les fichiers non trouvés. Nous utilisons la fonction std :: quoi () pour détecter l'exception qui renvoie une séquence de caractères nuls. Ensuite, nous utilisons la fonction Path () avec l'objet fichier_error "E". Enfin, nous imprimons la valeur, le message et la catégorie générés à partir de la fonction d'erreur du système de fichiers. Nous générons également une instruction de code d'erreur à partir de la fonction std :: error_code.

#inclure
#inclure
#inclure
int main()

const std :: filesystem :: path from "/ nofile1 / a", to "/ nofile2 / b";
essayer
std :: FileSystem :: copy_file (de, à);

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

Les erreurs sont générées par la fonction File_error car aucun fichier ou répertoire n'est trouvé.

Exemple 4: Utilisation de STD :: Système de fichiers :: Fonction absolue

Nous avons une autre fonction WHUS est le «STD :: Système :: Absolute» qui donne le chemin absolu du fichier. Un chemin est absolu qui comprend toujours le composant de base et la liste des répertoires entière qui sont nécessaires pour trouver le fichier. Ici, à l'intérieur de la fonction principale, nous utilisons la fonction STD :: Système :: Path et créons son objet comme «FP». Ensuite, nous donnons le chemin du fichier comme «principal.C ". Nous affichons le chemin actuel du fichier et le chemin d'accès absolu du fichier spécifié avec la commande cout. Le chemin absolu est affiché en passant l'objet de chemin de fichier «FP» dans la fonction «std :: fileSystem :: Absolute».

#inclure
#inclure
Espace de noms fs = std :: Système de fichiers;
int main()

STD :: Système de fichiers :: Path FP = "Main.C ";
std :: cout << "Current path " << fs::current_path() << '\n';
std :: cout << "Absolute path of" << fp << " is "
<< std::filesystem::absolute(fp) << '\n';

Nous pouvons voir le chemin d'accès actuel du fichier dans notre système et le chemin absolu du fichier obtenu à partir de la fonction absolue du système de fichiers.

Conclusion

La bibliothèque STD :: Système de fichiers, qui a une gamme de fonctionnalités, est introduite dans C ++ 17. Mais nous n'avons couvert que quelques fonctions du système de fichiers. Une bibliothèque standard contient des classes et des fonctions très bénéfiques et soigneusement construites à gérer, et la manipulation spécifique au système d'exploitation est abstraite. Nous avons implémenté le fichier Système Fonction File_exist pour connaître l'existence du fichier dans notre premier exemple. Ensuite, nous avons utilisé la fonction de taille de fichier pour obtenir la taille du fichier. De plus, nous avons utilisé la fonction d'erreur du système de fichiers pour montrer comment les exceptions sont générées dans un fichier. Nous avons également utilisé la fonction absolue du système de fichiers pour récupérer le chemin absolu du fichier.