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

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

Eh bien, j'ai créé un programme de test qui exécutait chacune de ces méthodes 100 000 fois, la moitié sur des fichiers qui existaient et l'autre 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 cycles,

Method exists_test0 (ifstream): **0.485s**
Method exists_test1 (FILE fopen): **0.302s**
Method exists_test2 (posix access()): **0.202s**
Method exists_test3 (posix stat()): **0.134s**

La stat()fonction a fourni les meilleures performances sur mon système (Linux, compilé avec g++), avec un fopenappel standard étant votre meilleur pari si vous refusez pour une raison quelconque d'utiliser les fonctions POSIX.

Remarque: en C ++ 14 et dès que le 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");

J'utilise ce morceau de code, cela fonctionne bien avec moi jusqu'à présent. Cela n'utilise pas de nombreuses fonctionnalités sophistiquées de C ++:

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

Cela dépend de l'emplacement des 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 vérifier tous les noms par rapport à la table de hachage. Cela peut être plus rapide sur certains systèmes que de vérifier chaque fichier individuellement. La façon la plus rapide de vérifier chaque fichier individuellement dépend de votre système ... si vous écrivez ANSI C, la façon la plus rapide est fopenparce que c'est la seule façon (un fichier peut exister mais ne peut pas être ouvert, mais vous voulez probablement vraiment l'ouvrir si vous besoin de "faire quelque chose"). C ++, POSIX, Windows offrent tous des options supplémentaires.

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

Pour ceux qui aiment le boost:

 boost::filesystem::exists(fileName)

Sans utiliser d'autres bibliothèques, j'aime utiliser l'extrait de code suivant:

#ifdef _WIN32
   #include <io.h> 
   #define access    _access_s
#else
   #include <unistd.h>
#endif

bool FileExists( const std::string &Filename )
{
    return access( Filename.c_str(), 0 ) == 0;
}

Cela fonctionne sur plusieurs plates-formes pour les systèmes Windows et compatibles POSIX.

Identique à celle suggérée par PherricOxide mais en C

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

inline bool exist(const std::string& name)
{
    ifstream file(name);
    if(!file)            // If the file was not found, then file is 0, i.e. !file=1 or true.
        return false;    // The file was not found.
    else                 // If the file was found, then file is non-0.
        return true;     // The file was found.
}

3 autres options sous Windows:

1

inline bool exist(const std::string& name)
{
    OFSTRUCT of_struct;
    return OpenFile(name.c_str(), &of_struct, OF_EXIST) != INVALID_HANDLE_VALUE && of_struct.nErrCode == 0;
}

2

inline bool exist(const std::string& name)
{
    HANDLE hFile = CreateFile(name.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile != NULL && hFile != INVALID_HANDLE)
    {
         CloseFile(hFile);
         return true;
    }
    return false;
}

3

inline bool exist(const std::string& name)
{
    return GetFileAttributes(name.c_str()) != INVALID_FILE_ATTRIBUTES;
}

Vous pouvez également le faire bool b = std::ifstream('filename').good();. Sans les instructions de branchement (comme si), il doit fonctionner plus rapidement car il doit être appelé des milliers de fois.

Si vous devez faire la distinction entre un fichier et un répertoire, tenez compte des éléments suivants, qui utilisent tous deux stat, l'outil standard le plus rapide, comme le montre PherricOxide:

#include <sys/stat.h>
int FileExists(char *path)
{
    struct stat fileStat; 
    if ( stat(path, &fileStat) )
    {
        return 0;
    }
    if ( !S_ISREG(fileStat.st_mode) )
    {
        return 0;
    }
    return 1;
}

int DirExists(char *path)
{
    struct stat fileStat;
    if ( stat(path, &fileStat) )
    {
        return 0;
    }
    if ( !S_ISDIR(fileStat.st_mode) )
    {
        return 0;
    }
    return 1;
}

J'ai besoin d'une fonction rapide qui peut vérifier si un fichier existe ou non et la réponse de PherricOxide est presque ce dont j'ai besoin, sauf qu'elle ne compare pas les performances de boost :: filesystem :: exist et les fonctions ouvertes. D'après les résultats de référence, nous pouvons facilement constater que:

• L'utilisation de la fonction stat est le moyen le plus rapide de vérifier si un fichier existe. Notez que mes résultats sont cohérents avec ceux de la réponse de PherricOxide.

• La performance de la fonction boost :: filesystem :: exist est très proche de celle de la fonction stat et elle est également portable. Je recommanderais cette solution si les bibliothèques boost sont accessibles à partir de votre code.

Résultats de référence obtenus avec le noyau Linux 4.17.0 et gcc-7.3:

2018-05-05 00:35:35
Running ./filesystem
Run on (8 X 2661 MHz CPU s)
CPU Caches:
  L1 Data 32K (x4)
  L1 Instruction 32K (x4)
  L2 Unified 256K (x4)
  L3 Unified 8192K (x1)
--------------------------------------------------
Benchmark           Time           CPU Iterations
--------------------------------------------------
use_stat          815 ns        813 ns     861291
use_open         2007 ns       1919 ns     346273
use_access       1186 ns       1006 ns     683024
use_boost         831 ns        830 ns     831233

Voici mon code de référence:

#include <string.h>                                                                                                                                                                                                                                           
#include <stdlib.h>                                                                                                                                                                                                                                           
#include <sys/types.h>                                                                                                                                                                                                                                        
#include <sys/stat.h>                                                                                                                                                                                                                                         
#include <unistd.h>                                                                                                                                                                                                                                           
#include <dirent.h>                                                                                                                                                                                                                                           
#include <fcntl.h>                                                                                                                                                                                                                                            
#include <unistd.h>                                                                                                                                                                                                                                           

#include "boost/filesystem.hpp"                                                                                                                                                                                                                               

#include <benchmark/benchmark.h>                                                                                                                                                                                                                              

const std::string fname("filesystem.cpp");                                                                                                                                                                                                                    
struct stat buf;                                                                                                                                                                                                                                              

// Use stat function                                                                                                                                                                                                                                          
void use_stat(benchmark::State &state) {                                                                                                                                                                                                                      
    for (auto _ : state) {                                                                                                                                                                                                                                    
        benchmark::DoNotOptimize(stat(fname.data(), &buf));                                                                                                                                                                                                   
    }                                                                                                                                                                                                                                                         
}                                                                                                                                                                                                                                                             
BENCHMARK(use_stat);                                                                                                                                                                                                                                          

// Use open function                                                                                                                                                                                                                                          
void use_open(benchmark::State &state) {                                                                                                                                                                                                                      
    for (auto _ : state) {                                                                                                                                                                                                                                    
        int fd = open(fname.data(), O_RDONLY);                                                                                                                                                                                                                
        if (fd > -1) close(fd);                                                                                                                                                                                                                               
    }                                                                                                                                                                                                                                                         
}                                                                                                                                                                                                                                                             
BENCHMARK(use_open);                                  
// Use access function                                                                                                                                                                                                                                        
void use_access(benchmark::State &state) {                                                                                                                                                                                                                    
    for (auto _ : state) {                                                                                                                                                                                                                                    
        benchmark::DoNotOptimize(access(fname.data(), R_OK));                                                                                                                                                                                                 
    }                                                                                                                                                                                                                                                         
}                                                                                                                                                                                                                                                             
BENCHMARK(use_access);                                                                                                                                                                                                                                        

// Use boost                                                                                                                                                                                                                                                  
void use_boost(benchmark::State &state) {                                                                                                                                                                                                                     
    for (auto _ : state) {                                                                                                                                                                                                                                    
        boost::filesystem::path p(fname);                                                                                                                                                                                                                     
        benchmark::DoNotOptimize(boost::filesystem::exists(p));                                                                                                                                                                                               
    }                                                                                                                                                                                                                                                         
}                                                                                                                                                                                                                                                             
BENCHMARK(use_boost);                                                                                                                                                                                                                                         

BENCHMARK_MAIN();   

Vous pouvez utiliser std::ifstream, funcion comme is_open, failpar exemple comme ci - dessous le code (le Cout exist fichier « ouvert » moyens ou non):

cité à partir de cette réponse

all_of (begin(R), end(R), [](auto&p){ exists(p); })

où Rest votre séquence de choses semblables à un chemin, et exists()vient du futur std ou boost actuel. Si vous lancez le vôtre, restez simple,

bool exists (string const& p) { return ifstream{p}; }

La solution ramifiée n'est pas absolument terrible et ne gobera pas les descripteurs de fichiers,

bool exists (const char* p) {
    #if defined(_WIN32) || defined(_WIN64)
    return p && 0 != PathFileExists (p);
    #else
    struct stat sb;
    return p && 0 == stat (p, &sb);
    #endif
}

En C ++ 17:

#include <experimental/filesystem>

bool is_file_exist(std::string& str) {   
    namespace fs = std::experimental::filesystem;
    fs::path p(str);
    return fs::exists(p);
}

En utilisant MFC, il est possible avec les éléments suivants

CFileStatus FileStatus;
BOOL bFileExists = CFile::GetStatus(FileName,FileStatus);

Où se FileNametrouve une chaîne représentant le fichier dont vous vérifiez l'existence

il n'y a qu'une seule façon plus rapide de vérifier si le fichier existe et si vous avez la permission de le lire, la façon d'utiliser le langage C est plus rapide et peut être utilisée aussi dans n'importe quelle version en C ++

solution : en C il y a une bibliothèque errno.h qui a une variable entière (globale) externe appelée errno qui contient un nombre qui peut être utilisé pour reconnaître le type d'erreur

    #include <stdio.h>
    #include <stdbool.h>
    #include <errno.h>

    bool isFileExist(char fileName[]) {
        FILE *fp = fopen(fileName, "r");
        if (fp) {
            fclose(fp);
            return true;
        }
        return errno != ENOENT;
    }

    bool isFileCanBeRead(char fileName[]) {
        FILE *fp = fopen(fileName, "r");
        if (fp) {
            fclose(fp);
            return true;
        }
        return errno != ENOENT && errno != EPERM;
    }

Bien qu'il existe plusieurs façons de le faire, la solution la plus efficace à votre problème serait probablement d'utiliser l'une des méthodes prédéfinies du fstream telles que good () . Avec cette méthode, vous pouvez vérifier si le fichier que vous avez spécifié existe ou non.

fstream file("file_name.txt");

if (file.good()) 
{
    std::cout << "file is good." << endl;
}
else 
{
    std::cout << "file isnt good" << endl;
}

J'espère que vous trouvez ça utile.