Le moyen le plus rapide de vérifier si un fichier existe en utilisant le standard C++/C++11,14,17/C ?

Question

Je voudrais trouver le moyen le plus rapide de vérifier si un fichier existe en C++11, 14, 17 ou C standard. J'ai des milliers de fichiers et avant de faire quelque chose sur eux, je dois vérifier s'ils existent tous. Que puis-je écrire à la place de /* SOMETHING */ dans la fonction suivante ?

inline bool exist(const std::string& name)
{
    /* SOMETHING */
}

Answer 1

J'ai créé un programme de test qui a exécuté chacune de ces méthodes 100 000 fois, la moitié sur des fichiers qui existaient et l'autre moitié sur des fichiers qui n'existaient pas.

#include <sys/stat.h>
#include <unistd.h>
#include <string>
#include <fstream>

inline bool exists_test0 (const std::string& name) {
    ifstream f(name.c_str());
    return f.good();
}

inline bool exists_test1 (const std::string& name) {
    if (FILE *file = fopen(name.c_str(), "r")) {
        fclose(file);
        return true;
    } else {
        return false;
    }   
}

inline bool exists_test2 (const std::string& name) {
    return ( access( name.c_str(), F_OK ) != -1 );
}

inline bool exists_test3 (const std::string& name) {
  struct stat buffer;   
  return (stat (name.c_str(), &buffer) == 0); 
}

Résultats pour le temps total pour exécuter les 100 000 appels en moyenne sur 5 exécutions,

Méthode

Temps

exists_test0 (ifstream)

0.485s

exists_test1 (FILE fopen)

0.302s

exists_test2 (posix access())

0.202s

exists_test3 (posix stat())

0.134s

Le site stat() a fourni les meilleures performances sur mon système (Linux, compilé avec g++ ), avec une norme fopen call étant votre meilleure option si vous refusez, pour une raison ou une autre, d'utiliser les fonctions POSIX.

Answer 2

Remarque : en C++14 et dès que la fonction Système de fichiers TS sera terminé et adopté, la solution sera d'utiliser :

std::experimental::filesystem::exists("helloworld.txt");

et depuis C++17, seulement :

std::filesystem::exists("helloworld.txt");

Answer 3

J'utilise ce morceau de code, qui fonctionne bien pour moi jusqu'à présent. Il n'utilise pas beaucoup de fonctionnalités sophistiquées du C++ :

bool is_file_exist(const char *fileName)
{
    std::ifstream infile(fileName);
    return infile.good();
}

Answer 4

Cela dépend de l'endroit où se trouvent les fichiers. Par exemple, s'ils sont tous censés se trouver dans le même répertoire, vous pouvez lire toutes les entrées du répertoire dans une table de hachage, puis comparer tous les noms à cette table. Ceci pourrait est plus rapide sur certains systèmes que de vérifier chaque fichier individuellement. La méthode la plus rapide pour vérifier chaque fichier individuellement dépend de votre système ... si vous écrivez en ANSI C, la méthode la plus rapide est la suivante fopen parce que c'est le seul moyen (un fichier peut exister mais ne pas être ouvrable, mais vous voulez probablement vraiment qu'il soit ouvrable si vous devez "faire quelque chose dessus"). C++, POSIX, Windows offrent tous des options supplémentaires.

Pendant que j'y suis, permettez-moi de souligner certains problèmes liés à votre question. Vous dites que vous voulez le moyen le plus rapide, et que vous avez des milliers de fichiers, mais ensuite vous demandez le code d'une fonction pour tester un seul fichier (et cette fonction n'est valable qu'en C++, pas en C). Cela contredit vos exigences en faisant une hypothèse sur la solution ... un cas de le problème XY . Vous dites également "en c++11(ou)c++(ou)c standard" ... qui sont tous différents, et cela est également incompatible avec votre exigence de rapidité ... la solution la plus rapide impliquerait d'adapter le code au système cible. L'incohérence de la question est soulignée par le fait que vous avez accepté une réponse qui donne des solutions qui dépendent du système et qui ne sont pas du C ou C++ standard.

Answer 5

Identique à la suggestion de PherricOxide mais en C

#include <sys/stat.h>
int exist(const char *name)
{
  struct stat   buffer;
  return (stat (name, &buffer) == 0);
}