Vorrei trovare il modo più veloce per verificare se esiste un file in standard C ++ 11, C ++ o C. Ho migliaia di file e prima di fare qualcosa su di essi devo controllare se esistono tutti. Cosa posso scrivere invece che /* SOMETHING */nella seguente funzione?

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

Bene, ho messo insieme un programma di test che ha eseguito ciascuno di questi metodi 100.000 volte, metà su file esistenti e metà su file che non lo erano.

#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); 
}

Risultati per il tempo totale necessario per eseguire le 100.000 chiamate calcolate in media su 5 sessioni,

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()funzione ha fornito le migliori prestazioni sul mio sistema (Linux, compilato con g++), con una fopenchiamata standard che è la soluzione migliore se per qualche motivo si rifiuta di utilizzare le funzioni POSIX.

Nota: in C ++ 14 e non appena il filesystem TS sarà terminato e adottato, la soluzione sarà quella di utilizzare:

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

e dal C ++ 17, solo:

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

Uso questo pezzo di codice, finora funziona bene con me. Questo non usa molte fantasiose funzionalità di C ++:

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

Dipende da dove risiedono i file. Ad esempio, se si suppone che siano tutti nella stessa directory, è possibile leggere tutte le voci della directory in una tabella hash e quindi controllare tutti i nomi rispetto alla tabella hash. Questo potrebbe essere più veloce su alcuni sistemi rispetto al controllo di ciascun file singolarmente. Il modo più veloce per controllare ogni file individualmente dipende dal tuo sistema ... se stai scrivendo ANSI C, il modo più veloce è fopenperché è l'unico modo (un file potrebbe esistere ma non essere apribile, ma probabilmente vuoi davvero aprirlo se bisogno di "fare qualcosa"). C ++, POSIX, Windows offrono tutte opzioni aggiuntive.

Mentre ci sono, vorrei evidenziare alcuni problemi con la tua domanda. Dici che vuoi il modo più veloce e che hai migliaia di file, ma poi chiedi il codice per una funzione per testare un singolo file (e quella funzione è valida solo in C ++, non in C). Questo contraddice le tue esigenze facendo un presupposto sulla soluzione ... un caso del problema XY . Dici anche "nello standard c ++ 11 (o) c ++ (o) c" ... che sono tutti diversi, e questo è anche incompatibile con il tuo requisito di velocità ... la soluzione più veloce implicherebbe l'adattamento del codice al sistema di destinazione. L'incoerenza nella domanda è evidenziata dal fatto che hai accettato una risposta che fornisce soluzioni che dipendono dal sistema e non sono standard C o C ++.

Per coloro a cui piace boost:

 boost::filesystem::exists(fileName)

Senza usare altre librerie, mi piace usare il seguente frammento di codice:

#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;
}

Funziona su più piattaforme per sistemi compatibili con Windows e POSIX.

Come suggerito da PherricOxide ma in 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.
}

Altre 3 opzioni sotto 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;
}

Puoi anche farlo bool b = std::ifstream('filename').good();. Senza le istruzioni di diramazione (come se), deve funzionare più velocemente in quanto deve essere chiamato migliaia di volte.

Se è necessario distinguere tra un file e una directory, considerare quanto segue che utilizza sia stat che lo strumento standard più veloce, come dimostrato da 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;
}

Ho bisogno di una funzione veloce in grado di verificare se esiste un file o meno e la risposta di PherricOxide è quasi ciò di cui ho bisogno, tranne che non confronta le prestazioni di boost :: filesystem :: esiste e funzioni aperte. Dai risultati del benchmark possiamo facilmente vedere che:

• L'uso della funzione stat è il modo più rapido per verificare l'esistenza di un file. Nota che i miei risultati sono coerenti con quelli della risposta di PherricOxide.

• Le prestazioni della funzione boost :: filesystem :: esiste sono molto simili a quelle della funzione stat ed è anche portatile. Consiglierei questa soluzione se le librerie boost sono accessibili dal tuo codice.

Risultati benchmark ottenuti con kernel Linux 4.17.0 e 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

Di seguito è riportato il mio codice di riferimento:

#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();   

Puoi usare std::ifstreamfunzioni come is_open, failad esempio come sotto il codice (il cout "aperto" significa che il file esiste o no):

citato da questa risposta

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

dov'è la Rtua sequenza di cose simili a percorsi, e exists()proviene dal futuro std o boost attuale. Se arrotoli il tuo, mantienilo semplice,

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

La soluzione ramificata non è assolutamente terribile e non inghiottirà i descrittori di file,

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
}

In 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);
}

Utilizzando MFC è possibile con quanto segue

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

Dov'è FileNameuna stringa che rappresenta il file che stai verificando per l'esistenza

c'è solo un modo più veloce per verificare se il file esiste e se hai il permesso di leggerlo il modo in cui usa il linguaggio C è più veloce e può essere usato anche in qualsiasi versione in C ++

soluzione : in C c'è una libreria errno.h che ha una variabile intera (globale) esterna chiamata errno che contiene un numero che può essere usato per riconoscere il tipo di errore

    #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;
    }

Sebbene ci siano diversi modi per farlo, la soluzione più efficiente al tuo problema sarebbe probabilmente quella di utilizzare uno dei metodi predefiniti del flusso come good () . Con questo metodo puoi verificare se il file che hai specificato esiste o meno.

fstream file("file_name.txt");

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

Spero che lo trovi utile