HOWTO · C++
Comment vérifier si un fichier existe en C++
Cet article présente plusieurs façons de vérifier si un fichier existe dans un répertoire C++
Sur cette page
Utilisez std::filesystem::exists pour vérifier si un chemin désigne une entrée existante du système de fichiers. La fonction renvoie true aussi bien pour les fichiers que pour les répertoires. L’exemple ci-dessous crée un petit répertoire temporaire et un fichier afin de fournir une entrée autonome au contrôle ; remplacez file par le chemin que votre programme doit examiner.
Utiliser std::filesystem::exists pour vérifier si un fichier existe dans un répertoire
Exécutez cet exemple :
#include <chrono>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>
int main() {
namespace fs = std::filesystem;
const auto unique = std::chrono::steady_clock::now().time_since_epoch().count();
const fs::path folder = fs::temp_directory_path() /
("cpp-exists-" + std::to_string(unique));
std::error_code ec;
if (!fs::create_directory(folder, ec) || ec) {
std::cout << "Could not prepare example\n";
return 1;
}
struct cleanup_guard {
fs::path path;
~cleanup_guard() {
std::error_code cleanup_error;
fs::remove_all(path, cleanup_error);
}
} cleanup{folder};
const fs::path file = folder / "notes.txt";
{
std::ofstream output(file);
if (!output) {
std::cout << "Could not prepare example\n";
return 1;
}
}
std::cout << (fs::exists(file) ? "Path exists\n" : "Path does not exist\n");
std::cout << (fs::is_regular_file(file) ? "It is a regular file\n"
: "It is not a regular file\n");
}
Path exists
It is a regular file
L’appel fs::exists(file) vérifie le chemin qui lui est transmis. Il ne recherche pas un fichier portant le même nom. Ici, folder / "notes.txt" associe un répertoire choisi à un nom de fichier au moyen de std::filesystem::path, qui gère le séparateur de chemin propre à la plateforme. Utilisez la même méthode avec le chemin de votre répertoire lorsque la cible se trouve hors du répertoire de travail courant du processus.
Un chemin relatif tel que "notes.txt" est résolu à partir du répertoire de travail courant du processus, défini par l’environnement dans lequel le programme est lancé. Il n’est pas automatiquement résolu à partir du répertoire contenant l’exécutable. Pour consulter le répertoire de travail courant, appelez fs::current_path() ; pour le modifier pour le processus, utilisez fs::current_path(path) et gérez toute erreur de système de fichiers signalée. Construire un chemin à partir d’un répertoire connu est généralement plus clair lorsque vous souhaitez vérifier un seul emplacement.
exists indique si une entrée est présente, mais pas de quel type elle est. Utilisez fs::is_regular_file(path) si seule une entrée correspondant à un fichier ordinaire doit être retenue, ou fs::is_directory(path) si vous vous attendez à un répertoire. Ces contrôles peuvent aussi ne pas fournir de réponse exploitable si le programme n’a pas accès au système de fichiers ou si le chemin change pendant l’inspection. Si votre code doit distinguer ces situations, utilisez les surcharges qui acceptent std::error_code et examinez l’erreur séparément de la valeur booléenne renvoyée.
Par exemple, std::error_code ec; const bool found = fs::exists(path, ec); permet d’examiner à la fois found et ec : un résultat faux sans erreur signifie que le chemin n’existe pas, tandis qu’une erreur signalée indique pourquoi le contrôle n’a pas pu aboutir. La surcharge sans argument de code d’erreur signale les problèmes de système de fichiers en lançant une exception. Choisissez la forme avec code d’erreur si votre code doit continuer malgré des problèmes de système de fichiers prévisibles ; sinon, la forme avec exception permet de garder un contrôle simple et lisible. Un chemin peut aussi ne plus désigner la même entrée entre le contrôle et une ouverture ultérieure : utilisez donc le résultat comme réponse à une recherche, et non comme garantie que l’opération suivante réussira.
L’exemple utilise std::filesystem et crée son propre jeu de fichiers temporaire. Si la création du répertoire ou du fichier échoue, il affiche le message de préparation et renvoie un statut non nul. La garde de nettoyage tente de supprimer le répertoire temporaire à la sortie normale, et les erreurs de nettoyage sont ignorées. La requête utilise la surcharge qui lance une exception ; ainsi, une exception de système de fichiers non interceptée qui sort de main peut terminer le programme sans garantir l’exécution du destructeur de la garde. Sur le chemin normal, la sortie correspond aux deux lignes affichées plus haut. Les libellés de cet exemple restent en anglais, car les blocs de code et de sortie sont conservés à l’identique.