[c++] 표준 C ++ / C ++ 11 / C를 사용하여 파일이 있는지를 확인하는 가장 빠른 방법은 무엇입니까?



6 Answers

나는이 코드를 사용하여, 지금까지 나와 함께 잘 작동한다. 이것은 C ++의 많은 멋진 기능을 사용하지 않습니다.

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

나는 파일이 표준 C ++ 11, C ++ 또는 C에 있는지를 확인하는 가장 빠른 방법을 찾고 싶습니다. 수천 개의 파일이 있고 그 파일에 무언가를하기 전에 모든 파일이 있는지 확인해야합니다. /* SOMETHING */ 대신 다음 함수에서 쓸 수있는 것은 무엇입니까?

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



파일이있는 위치에 따라 다릅니다. 예를 들어, 모두 같은 디렉토리에 있다고 가정하면 모든 디렉토리 항목을 해시 테이블로 읽어 들여 해시 테이블에 대해 모든 이름을 확인할 수 있습니다. 일부 시스템에서는 각 파일을 개별적으로 검사하는 것보다 빠를 수도 있습니다. 각 파일을 개별적으로 검사하는 가장 빠른 방법은 시스템에 따라 다릅니다 ... ANSI C를 작성하는 경우 가장 빠른 방법은 파일이기 때문에 가능하지만 파일을 열 수는 없기 때문에 fopen . 그러나 if open ifable if 당신은 "그것에 뭔가를해야한다"). C ++, POSIX, Windows는 모두 추가 옵션을 제공합니다.

제가 그 동안 질문에 대한 몇 가지 문제점을 지적하겠습니다. 가장 빠른 방법을 원하고 수천 개의 파일을 가지고 있다고하지만, 단일 파일을 테스트하는 함수의 코드를 요청합니다.이 함수는 C가 아닌 C ++에서만 유효합니다. 이것은 해결책에 대한 가정을함으로써 요구 사항을 모순됩니다 ... XY 문제 의 경우. 또한 "표준 C ++ 11 (또는) C ++ (또는) C"... 모두 다르고, 이것은 또한 속도에 대한 요구 사항과 일치하지 않습니다 ... 가장 빠른 솔루션은 코드를 목표 시스템. 이 질문의 불일치는 시스템 의존적이고 표준 C 또는 C ++가 아닌 솔루션을 제공하는 대답을 받아 들인 사실에 의해 강조됩니다.




파일과 디렉토리를 구분할 필요가있는 경우 PherricOxide에서 보여준 가장 빠른 표준 도구 인 stat를 사용하는 다음을 고려하십시오.

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



bool b = std::ifstream('filename').good(); 수행 할 수도 있습니다 bool b = std::ifstream('filename').good(); . if와 같은 분기 명령어가 없으면 수천 번 호출해야하므로 더 빨리 수행해야합니다.




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.
}



파일이 존재하는지 여부를 확인할 수있는 빠른 함수가 필요하며 PherricOxide의 대답은 boost :: filesystem :: exists 및 open 함수의 성능을 비교하지 않는다는 점을 제외하고는 거의 필요한 것입니다. 벤치 마크 결과에서 우리는 다음과 같은 것을 쉽게 볼 수 있습니다 :

  • stat 함수를 사용하는 것은 파일이 있는지를 확인하는 가장 빠른 방법입니다. 제 결과는 PherricOxide의 답변과 일치합니다.

  • boost :: filesystem :: exists 함수의 성능은 stat 함수의 성능과 매우 비슷하며 이식성이 뛰어납니다. 귀하의 코드에서 부스트 라이브러리에 액세스 할 수 있다면이 솔루션을 권하고 싶습니다.

Linux 커널 4.17.0 및 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

아래는 내 벤치 마크 코드입니다.

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



다른 라이브러리를 사용하지 않고 다음 코드 스 니펫을 사용하고 싶습니다.

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

이것은 Windows 및 POSIX 호환 시스템에서 크로스 플랫폼으로 작동합니다.




Related