Tôi muốn tìm cách nhanh nhất để kiểm tra xem một tệp có tồn tại trong C ++ 11, C ++ hoặc C. chuẩn hay không. Tôi có hàng ngàn tệp và trước khi thực hiện chúng, tôi cần kiểm tra xem tất cả chúng có tồn tại không. Tôi có thể viết gì thay vì /* SOMETHING */trong chức năng sau đây?

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

Vâng, tôi đã cùng nhau tạo ra một chương trình thử nghiệm chạy từng phương thức này 100.000 lần, một nửa cho các tệp tồn tại và một nửa trên các tệp không.

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

Kết quả cho tổng thời gian để chạy 100.000 cuộc gọi trung bình trên 5 lần chạy,

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**

Các stat()chức năng cung cấp hiệu suất tốt nhất trên hệ thống của tôi (Linux, biên soạn với g++), với một tiêu chuẩn fopengọi là đặt cược tốt nhất của bạn nếu bạn vì một lý do từ chối sử dụng các chức năng POSIX.

Lưu ý: trong C ++ 14 và ngay sau khi hệ thống tập tin TS sẽ kết thúc và được thông qua, giải pháp sẽ là sử dụng:

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

và kể từ C ++ 17, chỉ:

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

Tôi sử dụng đoạn mã này, nó hoạt động tốt với tôi cho đến nay. Điều này không sử dụng nhiều tính năng ưa thích của C ++:

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

Nó phụ thuộc vào nơi tập tin cư trú. Chẳng hạn, nếu tất cả chúng đều nằm trong cùng một thư mục, bạn có thể đọc tất cả các mục nhập thư mục vào bảng băm và sau đó kiểm tra tất cả các tên so với bảng băm. Điều này có thể nhanh hơn trên một số hệ thống hơn là kiểm tra từng tệp riêng lẻ. Cách nhanh nhất để kiểm tra từng tệp riêng lẻ tùy thuộc vào hệ thống của bạn ... nếu bạn đang viết ANSI C, cách nhanh nhất là fopenvì đó là cách duy nhất (một tệp có thể tồn tại nhưng không thể mở được, nhưng bạn có thể thực sự muốn mở nếu bạn cần phải "làm một cái gì đó trên nó"). C ++, POSIX, Windows đều cung cấp các tùy chọn bổ sung.

Trong khi tôi đang ở đó, hãy để tôi chỉ ra một số vấn đề với câu hỏi của bạn. Bạn nói rằng bạn muốn cách nhanh nhất và bạn có hàng ngàn tệp, nhưng sau đó bạn yêu cầu mã cho một hàm để kiểm tra một tệp duy nhất (và hàm đó chỉ hợp lệ trong C ++, không phải C). Điều này mâu thuẫn với các yêu cầu của bạn bằng cách đưa ra một giả định về giải pháp ... một trường hợp của vấn đề XY . Bạn cũng nói "trong tiêu chuẩn c ++ 11 (hoặc) c ++ (hoặc) c" ... hoàn toàn khác nhau và điều này cũng không phù hợp với yêu cầu của bạn về tốc độ ... giải pháp nhanh nhất sẽ liên quan đến việc điều chỉnh mã theo hệ thống mục tiêu. Sự không nhất quán trong câu hỏi được nhấn mạnh bởi thực tế là bạn đã chấp nhận một câu trả lời đưa ra các giải pháp phụ thuộc vào hệ thống và không phải là tiêu chuẩn C hoặc C ++.

Đối với những người thích boost:

 boost::filesystem::exists(fileName)

Không sử dụng các thư viện khác, tôi muốn sử dụng đoạn mã sau:

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

Điều này hoạt động đa nền tảng cho các hệ thống tuân thủ Windows và POSIX.

Tương tự như đề xuất của PherricOxide nhưng trong 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 tùy chọn khác dưới cửa sổ:

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

Bạn cũng có thể làm bool b = std::ifstream('filename').good();. Không có các hướng dẫn chi nhánh (như nếu), nó phải thực hiện nhanh hơn vì nó cần được gọi hàng ngàn lần.

Nếu bạn cần phân biệt giữa một tệp và một thư mục, hãy xem xét những điều sau đây cả hai đều sử dụng công cụ tiêu chuẩn nhanh nhất như được trình bày bởi 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;
}

Tôi cần một chức năng nhanh có thể kiểm tra xem một tệp có tồn tại hay không và câu trả lời của PherricOxide gần như là những gì tôi cần ngoại trừ nó không so sánh hiệu năng của boost :: filesystem :: tồn tại và các hàm mở. Từ kết quả điểm chuẩn, chúng ta có thể dễ dàng thấy rằng:

• Sử dụng chức năng stat là cách nhanh nhất để kiểm tra nếu một tập tin tồn tại. Lưu ý rằng kết quả của tôi phù hợp với câu trả lời của PherricOxide.

• Hiệu năng của hàm boost :: filesystem :: rất gần với chức năng của stat và nó cũng có thể mang theo được. Tôi muốn giới thiệu giải pháp này nếu các thư viện boost có thể truy cập được từ mã của bạn.

Kết quả điểm chuẩn thu được với nhân Linux 4.17.0 và 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

Dưới đây là mã điểm chuẩn của tôi:

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

Bạn có thể sử dụng std::ifstream, funcion như is_open, failví dụ như sau mã (các cout có nghĩa là "mở" tập tin tồn tại hay không):

trích dẫn từ câu trả lời này

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

đâu Rlà chuỗi các thứ giống như đường dẫn của bạn, và exists()là từ tiêu chuẩn tương lai hoặc tăng hiện tại. Nếu bạn tự cuộn, hãy giữ nó đơn giản,

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

Giải pháp phân nhánh không hoàn toàn khủng khiếp và nó sẽ không ngấu nghiến mô tả tập tin,

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
}

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

Có thể sử dụng MFC với những điều sau đây

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

Đâu FileNamelà một chuỗi đại diện cho tệp bạn đang kiểm tra sự tồn tại

Chỉ có một cách nhanh hơn để kiểm tra xem tệp có tồn tại hay không và nếu bạn có quyền đọc nó thì cách sử dụng ngôn ngữ C mong muốn nhanh hơn và cũng có thể được sử dụng trong bất kỳ phiên bản nào trong C ++

Giải pháp : trong C có một thư viện errno.h có một biến số nguyên (toàn cầu) bên ngoài được gọi là errno chứa một số có thể được sử dụng để nhận ra loại lỗi

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

Mặc dù có một số cách để làm điều này, giải pháp hiệu quả nhất cho vấn đề của bạn có lẽ là sử dụng một trong những phương pháp được xác định trước của fux, chẳng hạn như good () . Với phương pháp này, bạn có thể kiểm tra xem tệp bạn đã chỉ định có tồn tại hay không.

fstream file("file_name.txt");

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

Tôi hy vọng bạn thấy nó hữu dụng.