ฉันต้องการค้นหาวิธีที่เร็วที่สุดในการตรวจสอบว่าไฟล์มีอยู่ในมาตรฐาน C ++ 11, C ++ หรือ C ฉันมีไฟล์หลายพันไฟล์และก่อนที่จะทำอะไรกับพวกเขาฉันต้องตรวจสอบว่ามีอยู่ทั้งหมดหรือไม่ ฉันสามารถเขียนอะไรได้บ้าง/* SOMETHING */ในฟังก์ชั่นต่อไปนี้

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

ฉันรวมโปรแกรมทดสอบที่ใช้แต่ละวิธี 100,000 ครั้งครึ่งหนึ่งบนไฟล์ที่มีอยู่และอีกครึ่งหนึ่งในไฟล์ที่ไม่ได้

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

ผลลัพธ์สำหรับเวลาทั้งหมดในการเรียกใช้ 100,000 การโทรโดยเฉลี่ยมากกว่า 5 ครั้ง

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

stat()ฟังก์ชั่นที่ให้ประสิทธิภาพที่ดีที่สุดในระบบของฉัน (ลินุกซ์คอมไพล์ด้วยg++) ที่มีมาตรฐานfopenการโทรเป็นทางออกที่ดีที่สุดของคุณถ้าคุณสำหรับบางคนปฏิเสธเหตุผลที่จะใช้ฟังก์ชั่น POSIX

หมายเหตุ: ใน C ++ 14 และทันทีที่ระบบไฟล์ TSเสร็จสิ้นและปรับใช้โซลูชันจะใช้:

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

และตั้งแต่ C ++ 17 เท่านั้น:

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

ฉันใช้รหัสชิ้นนี้มันใช้งานได้ดีกับฉันจนถึงตอนนี้ สิ่งนี้ไม่ได้ใช้คุณสมบัติแฟนซีมากมายของ C ++:

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

ขึ้นอยู่กับว่าไฟล์อยู่ที่ไหน ตัวอย่างเช่นหากพวกเขาทั้งหมดควรจะอยู่ในไดเรกทอรีเดียวกันคุณสามารถอ่านรายการไดเรกทอรีทั้งหมดลงในตารางแฮชแล้วตรวจสอบชื่อทั้งหมดกับตารางแฮช สิ่งนี้อาจเร็วกว่าในบางระบบมากกว่าการตรวจสอบแต่ละไฟล์ วิธีที่เร็วที่สุดในการตรวจสอบแต่ละไฟล์นั้นขึ้นอยู่กับระบบของคุณ ... ถ้าคุณกำลังเขียน ANSI C วิธีที่เร็วที่สุดก็คือfopenเพราะมันเป็นวิธีเดียว (ไฟล์อาจมีอยู่ แต่ไม่สามารถเปิดได้ แต่คุณอาจต้องการเปิดได้จริงๆถ้าคุณ จำเป็นต้อง "ทำอะไรกับมัน") C ++, POSIX, Windows ทั้งหมดมีตัวเลือกเพิ่มเติม

ในขณะที่ฉันอยู่ที่นี่ขอให้ฉันชี้ปัญหาบางอย่างกับคำถามของคุณ คุณบอกว่าคุณต้องการวิธีที่เร็วที่สุดและคุณมีไฟล์นับพัน แต่คุณขอรหัสเพื่อให้ฟังก์ชั่นทดสอบไฟล์เดียว (และฟังก์ชันนั้นใช้ได้เฉพาะใน C ++ ไม่ใช่ C) นี้ขัดแย้งกับความต้องการของคุณโดยการทำให้สมมติฐานเกี่ยวกับการแก้ปัญหา ... กรณีของปัญหา XY นอกจากนี้คุณยังพูดว่า "ในมาตรฐาน c ++ 11 (หรือ) c ++ (หรือ) c" ... ซึ่งแตกต่างกันทั้งหมดและสิ่งนี้ก็ไม่สอดคล้องกับความต้องการของคุณสำหรับความเร็ว ... โซลูชันที่เร็วที่สุดจะเกี่ยวข้องกับการปรับแต่งรหัสให้เหมาะกับ ระบบเป้าหมาย ความไม่สอดคล้องกันในคำถามถูกเน้นด้วยข้อเท็จจริงที่ว่าคุณยอมรับคำตอบที่ให้วิธีการแก้ปัญหาที่ขึ้นอยู่กับระบบและไม่ใช่ C หรือ C ++ มาตรฐาน

สำหรับผู้ที่ชอบเพิ่ม:

 boost::filesystem::exists(fileName)

หากไม่ใช้ห้องสมุดอื่นฉันชอบใช้ข้อมูลโค้ดต่อไปนี้:

#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

เหมือนกับที่ PherricOxide แนะนำ แต่เป็น 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 ตัวเลือกภายใต้ 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;
}

bool b = std::ifstream('filename').good();นอกจากนี้คุณยังอาจจะทำ หากไม่มีคำสั่งสาขา (เช่นถ้า) จะต้องทำงานได้เร็วขึ้นเนื่องจากต้องเรียกหลายพันครั้ง

หากคุณต้องการแยกความแตกต่างระหว่างไฟล์และไดเรกทอรีให้พิจารณาสิ่งต่อไปนี้ซึ่งทั้งสองใช้สถิติที่เป็นเครื่องมือมาตรฐานที่เร็วที่สุดตามที่แสดงโดย 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;
}

ฉันต้องการฟังก์ชั่นเร็วที่สามารถตรวจสอบว่ามีไฟล์อยู่หรือไม่และคำตอบของ PherricOxide นั้นเกือบจะเป็นสิ่งที่ฉันต้องการยกเว้นมันไม่ได้เปรียบเทียบประสิทธิภาพของ boost :: filesystem :: มีอยู่และฟังก์ชั่นเปิด จากผลการวัดประสิทธิภาพเราจะเห็นว่า:

• การใช้ฟังก์ชั่นสถิติเป็นวิธีที่เร็วที่สุดในการตรวจสอบว่ามีไฟล์อยู่หรือไม่ โปรดทราบว่าผลลัพธ์ของฉันสอดคล้องกับคำตอบของ PherricOxide

• ประสิทธิภาพการทำงานของ boost :: ระบบแฟ้ม :: ฟังก์ชันที่มีอยู่นั้นใกล้เคียงกับฟังก์ชั่นสถิติมากและยังพกพาได้ ฉันจะแนะนำวิธีแก้ปัญหานี้หากห้องสมุดเพิ่มสามารถเข้าถึงได้จากรหัสของคุณ

ได้รับผลการทดสอบเกณฑ์มาตรฐานด้วย Linux kernel 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();   

คุณสามารถใช้std::ifstream, funcion เช่นis_open, failยกตัวอย่างดังต่อไปนี้รหัส (คนศาล "เปิด" หมายถึงการมีอยู่ของไฟล์หรือไม่):

อ้างจากคำตอบนี้

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

Rลำดับของสิ่งที่เหมือนเส้นทางของคุณอยู่ที่ไหนและexists()มาจากมาตรฐานในอนาคตหรือการเพิ่มปัจจุบัน ถ้าคุณม้วนของคุณเองให้มันง่าย

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

ทางออกที่แตกแขนงนั้นไม่น่ากลัวอย่างยิ่งและจะไม่สามารถอธิบายไฟล์ฮุบได้

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
}

ใน 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);
}

การใช้ MFC เป็นไปได้ดังต่อไปนี้

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

ที่ไหนFileNameเป็นสตริงที่แสดงไฟล์ที่คุณกำลังตรวจสอบสำหรับการดำรงอยู่

มีเพียงวิธีเดียวที่เร็วกว่าในการตรวจสอบว่ามีไฟล์อยู่หรือไม่และหากคุณได้รับอนุญาตให้อ่านวิธีที่ใช้ภาษา C นั้นต้องการได้เร็วขึ้นและสามารถใช้ได้กับทุกรุ่นใน C ++

วิธีแก้ปัญหา : ใน C มีไลบรารีerrno.hซึ่งมีตัวแปรจำนวนเต็ม (ทั่วโลก) ภายนอกที่เรียกว่า errno ซึ่งมีหมายเลขที่สามารถใช้เพื่อรับรู้ชนิดของข้อผิดพลาด

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

แม้ว่าจะมีหลายวิธีที่จะทำเช่นนี้เป็นทางออกที่มีประสิทธิภาพมากที่สุดในการแก้ไขปัญหาของคุณอาจจะใช้หนึ่งในวิธีการที่กำหนดไว้ล่วงหน้า fstream ของเช่นดี () ด้วยวิธีนี้คุณสามารถตรวจสอบว่าไฟล์ที่คุณระบุมีอยู่หรือไม่

fstream file("file_name.txt");

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

ฉันหวังว่าคุณจะพบว่ามีประโยชน์นี้