Quelle est la meilleure façon de vérifier si un fichier existe en C ++? (plateforme croisée)

J'ai lu les réponses pour Quelle est la meilleure façon de vérifier si un fichier existe en C? (multiplate-forme) , mais je me demande s'il existe une meilleure façon de le faire en utilisant des bibliothèques C ++ standard? De préférence sans essayer d'ouvrir le fichier du tout.

Les deux statet accesssont à peu près indomptables. Que dois-je #includeutiliser pour les utiliser?

Utilisez boost :: filesystem :

#include <boost/filesystem.hpp>

if ( !boost::filesystem::exists( "myfile.txt" ) )
{
  std::cout << "Can't find my file!" << std::endl;
}

Attention aux conditions de concurrence: si le fichier disparaît entre le contrôle «existe» et l'heure à laquelle vous l'ouvrez, votre programme échouera de manière inattendue.

Il vaut mieux aller ouvrir le fichier, vérifier l'échec et si tout va bien, faire quelque chose avec le fichier. C'est encore plus important avec le code critique pour la sécurité.

Détails sur la sécurité et les conditions de concurrence : http://www.ibm.com/developerworks/library/l-sprace.html

Je suis un utilisateur de boost heureux et j'utiliserais certainement la solution d'Andreas. Mais si vous n'avez pas accès aux bibliothèques boost, vous pouvez utiliser la bibliothèque de flux:

ifstream file(argv[1]);
if (!file)
{
    // Can't open file
}

Ce n'est pas aussi bien que boost :: filesystem :: existe puisque le fichier sera en fait ouvert ... mais c'est généralement la prochaine chose que vous voulez faire de toute façon.

Utilisez stat (), si elle est suffisamment multiplateforme pour vos besoins. Ce n'est pas le standard C ++, mais POSIX.

Sur MS Windows, il y a _stat, _stat64, _stati64, _wstat, _wstat64, _wstati64.

Et pourquoi pas access?

#include <io.h>

if (_access(filename, 0) == -1)
{
    // File does not exist
}

Une autre possibilité consiste à utiliser la good()fonction dans le flux:

#include <fstream>     
bool checkExistence(const char* filename)
{
     ifstream Infield(filename);
     return Infield.good();
}

Je reconsidérerais essayer de savoir si un fichier existe. Au lieu de cela, vous devriez essayer de l'ouvrir (en Standard C ou C ++) dans le même mode que vous avez l'intention de l'utiliser. À quoi sert de savoir que le fichier existe si, par exemple, il n'est pas accessible en écriture lorsque vous devez l'utiliser?

Si votre compilateur prend en charge C ++ 17, vous n'avez pas besoin de boost, vous pouvez simplement utiliser std::filesystem::exists

#include <iostream> // only for std::cout
#include <filesystem>

if (!std::filesystem::exists("myfile.txt"))
{
    std::cout << "File not found!" << std::endl;
}

NON renforcerREQUIS , ce qui serait exagéré .

Utilisez stat () (pas multiplateforme bien que comme mentionné par pavon), comme ceci:

#include <sys/stat.h>
#include <iostream>

// true if file exists
bool fileExists(const std::string& file) {
    struct stat buf;
    return (stat(file.c_str(), &buf) == 0);
}

int main() {
    if(!fileExists("test.txt")) {
        std::cerr << "test.txt doesn't exist, exiting...\n";
        return -1;
    }
    return 0;
}

Production:

C02QT2UBFVH6-lm:~ gsamaras$ ls test.txt
ls: test.txt: No such file or directory
C02QT2UBFVH6-lm:~ gsamaras$ g++ -Wall main.cpp
C02QT2UBFVH6-lm:~ gsamaras$ ./a.out
test.txt doesn't exist, exiting...

Une autre version (et celle) peut être trouvée ici .

Si vous utilisez déjà la classe de flux de fichier d'entrée ( ifstream), vous pouvez utiliser sa fonction fail().

Exemple:

ifstream myFile;

myFile.open("file.txt");

// Check for errors
if (myFile.fail()) {
    cerr << "Error: File could not be found";
    exit(1);
}