यह जांचने का सबसे तेज़ तरीका है कि क्या मानक C ++ / C ++ 11 / C का उपयोग करके कोई फ़ाइल मौजूद है?

Question

मैं जांचने का सबसे तेज़ तरीका खोजना चाहूंगा कि क्या कोई फ़ाइल मानक C ++ 11, C ++, या C. में मौजूद है। मेरे पास हजारों फाइलें हैं और उन पर कुछ करने से पहले मुझे यह जांचने की आवश्यकता है कि क्या उनमें से सभी मौजूद हैं। /* SOMETHING */निम्नलिखित फ़ंक्शन के बजाय मैं क्या लिख ​​सकता हूं ?

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

Comments

boost::filesystemका उपयोग करने लगता है stat()। (प्रलेखन से मान लें।) मुझे नहीं लगता कि आप एफएस कॉल के लिए बहुत तेजी से कर सकते हैं। आप जो कर रहे हैं, उसे बनाने का तरीका है "हजारों फ़ाइलों को देखने से बचें।"

— मिलिमोस

TOCTOU सवाल: आप कैसे जानते हैं कि फ़ाइल आपके (आपके) चेक और आपके "इस पर कुछ करने" के बीच अनलिंक नहीं है ?

— पाइक्रो

@pilcrow अच्छा बिंदु है, लेकिन अनुप्रयोगों की एक काफी विस्तृत श्रृंखला है, जिन्हें बहुत अधिक शुद्धता की आवश्यकता नहीं है। उदाहरण के लिए, git pushसंभवतः यह सुनिश्चित करने की जहमत नहीं उठाई जाती कि आप प्रारंभिक गंदे जाँच के बाद काम करने वाले पेड़ को नहीं छू रहे हैं।

— मिली

'मैं C / C ++ के कार्यान्वयन के बारे में नहीं सोच सकता जो ऐसा नहीं होगा' - विंडोज एक POSIX वातावरण प्रदान नहीं करता है।

— जिम बैटर

Std

— MD XF

Answer 1

अच्छी तरह से मैं एक परीक्षण कार्यक्रम है कि इन तरीकों में से प्रत्येक को 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); 
}

5 बार औसतन 100,000 कॉल चलाने के लिए कुल परिणाम,

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 कार्यों का उपयोग करने के लिए अपने सबसे अच्छे शर्त जा रहा है।

Comments

ऊपर दिए गए तरीकों में से कोई भी अस्तित्व के लिए जांच नहीं करता है, बल्कि पहुंच के लिए है। मैं अस्तित्व के लिए जाँच करने के लिए एक भी मानक C या C ++ तरीका नहीं जानता, हालाँकि।

— IInspectable

stat()अस्तित्व की जांच करने लगता है।

— el.pescado

इसका उपयोग करने वाले किसी को भी #include <sys / stat.h> को याद रखने की आवश्यकता है अन्यथा यह गलत स्टेट का उपयोग करने की कोशिश करता है।

— काटीनी

मैं ifstream विधि के लिए कल्पना करता हूं, आपको f.close()फ़ंक्शन के अंत में f के दायरे से बाहर जाने की आवश्यकता नहीं है । तो ब्लॉक की return f.good()जगह ले सकता है if?

— ilent2

तुम भी उपयोग कर सकते हैं / परीक्षण en.cppreference.com/w/cpp/experimental/fs/exists आगामी मानक से

— जहीर

Answer 2

टिप्पणी: C ++ 14 में और जैसे ही फाइलसिस्टम टीएस समाप्त हो जाएगा और अपनाया जाएगा, समाधान का उपयोग करना होगा:

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

और C ++ 17 के बाद से, केवल:

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

Comments

पहले से ही Boost.Filesystem

— TemplateRex

एमएस विज़ुअल स्टूडियो 2013 में यह समारोह के तहत उपलब्ध हैstd::tr2::sys::exists("helloworld.txt");

— कॉन्स्टैंटिन

मुझे वास्तव में उम्मीद है कि यह नहीं होगा std::exists, यह काफी भ्रामक होगा (सोचें: एक सेट की तरह एसटीएल कंटेनर में मौजूद है)।

— einpoklum

विजुअल स्टूडियो 2015 में भी:#include <experimental/filesystem> bool file_exists(std::string fn) { std::experimental::filesystem::exists("helloworld.txt"); }

— ऑरवेलोफाइल

मत भूलो#include <experimental/filesystem>

— मोहम्मद नौरेलिन

Answer 3

मैं इस कोड के टुकड़े का उपयोग करता हूं, यह मेरे साथ अब तक ठीक काम करता है। यह C ++ की कई फैंसी विशेषताओं का उपयोग नहीं करता है:

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

Comments

हालाँकि, यह विफल हो सकता है यदि फ़ाइल किसी अन्य प्रोग्राम द्वारा लॉक की गई थी या यदि फ़ाइल तक कोई पहुंच नहीं है।

— जेट

क्या आपको धारा बंद करने की आवश्यकता है?

— Mo0gles

@ Mo0gles: ifstreamविध्वंसक को बाहर निकलने पर बुलाया is_file_existजाएगा और यह धारा को बंद कर देगा।

— इसहाक

C ++ 11 के अनुसार, आप इसे बूल ऑपरेटर का उपयोग करके एक पंक्ति में कर सकते हैं: en.cppreference.com/w/cpp/io/basic_ios/operator_bool

— Mugen

@ ऑरवेलोफाइलreturn std::ifstream(fileName);

— इमली

Answer 4

यह निर्भर करता है कि फाइलें कहां रहती हैं। उदाहरण के लिए, यदि वे सभी एक ही निर्देशिका में होने वाले हैं, तो आप सभी निर्देशिका प्रविष्टियों को हैश तालिका में पढ़ सकते हैं और फिर हैश तालिका के विरुद्ध सभी नामों की जाँच कर सकते हैं। यह प्रत्येक फ़ाइल की व्यक्तिगत रूप से जाँच करने की तुलना में कुछ सिस्टम पर तेज़ हो सकता है। प्रत्येक फ़ाइल को व्यक्तिगत रूप से जांचने का सबसे तेज़ तरीका आपके सिस्टम पर निर्भर करता है ... यदि आप ANSI C लिख रहे हैं, तो सबसे तेज़ तरीका हैfopen क्योंकि यह एकमात्र तरीका है (एक फ़ाइल मौजूद हो सकती है, लेकिन ओपन करने योग्य नहीं है, लेकिन आप वास्तव में ओपन करना चाहते हैं यदि आप "इस पर कुछ करने की जरूरत है")। C ++, POSIX, Windows सभी अतिरिक्त विकल्प प्रदान करते हैं।

जब मैं इस पर हूँ, मुझे अपने प्रश्न के साथ कुछ समस्याओं की ओर इशारा करते हैं। आप कहते हैं कि आप सबसे तेज़ तरीका चाहते हैं, और यह कि आपके पास हज़ारों फाइलें हैं, लेकिन फिर आप किसी फ़ाइल के परीक्षण के लिए फ़ंक्शन के लिए कोड मांगते हैं (और यह फ़ंक्शन केवल C ++ में मान्य है, C नहीं)। यह समाधान के बारे में एक धारणा बनाकर आपकी आवश्यकताओं का खंडन करता है ... XY समस्या का एक मामला । आप यह भी कहते हैं "मानक c ++ 11 (या) c ++ (या) c" ... जो सभी अलग हैं, और यह भी गति के लिए आपकी आवश्यकता के साथ असंगत है ... सबसे तेज़ समाधान में कोड को सिलाई करना शामिल होगा। " लक्ष्य प्रणाली। प्रश्न में असंगतता को इस तथ्य से उजागर किया जाता है कि आपने एक उत्तर स्वीकार किया है जो समाधान देता है जो सिस्टम-निर्भर हैं और मानक सी या सी ++ नहीं हैं।

Answer 5

बढ़ावा देने वालों के लिए:

 boost::filesystem::exists(fileName)

Comments

बूस्ट आमतौर पर बेहद धीमा होता है।

— सर्ज रोजैग 15

अधिकांश अनुप्रयोगों के लिए एक फाइल मौजूद है चेक प्रदर्शन महत्वपूर्ण नहीं है

— anhoppe

एक उच्च प्रदर्शन आवेदन के सभी पहलुओं को अनुकूलन की आवश्यकता नहीं होती है। उदाहरण के लिए, कमांड लाइन या एक कॉन्फिग फाइल पढ़ना जटिल हो सकता है और इसमें गति की आवश्यकता नहीं हो सकती है, हालांकि एप्लिकेशन को स्वयं C ++ के प्रदर्शन लाभ की आवश्यकता हो सकती है। ऐसे मामलों में बूस्ट से बचने के लिए पहिया सुदृढीकरण का गठन होता है, विरोधी पैटर्न सूची में उच्च।

— evoskuil

@SergeRogatch को बढ़ावा देना :: filesystem :: मौजूद बहुत धीमी नहीं है। विस्तार से जानकारी के लिए मेरे बेंचमार्क परिणाम देखें।

— भूख लगी

"बूस्ट आमतौर पर बेहद धीमा होता है" - यह गलत है, और यह भी स्पष्ट नहीं है कि दावे का दायरा क्या है ... बूस्ट में अलग-अलग लेखकों द्वारा कई पैकेज शामिल हैं लेकिन उच्च गुणवत्ता के लिए वीटो किया गया है। "अधिकांश अनुप्रयोगों के लिए एक फ़ाइल मौजूद है चेक महत्वपूर्ण नहीं है" - ओपी ने विशेष रूप से बहुत बड़ी संख्या में फाइलों की जांच करने के कारण गति के लिए कहा है। "यदि प्रदर्शन महत्वपूर्ण नहीं है, तो C ++ का उपयोग करने का भी कोई मतलब नहीं है" - एक और गलत टिप्पणी (और विषय बंद)। अधिकांश सॉफ़्टवेयर दुकानों में लिखे गए हैं और एक ऐसी प्रणाली का हिस्सा है जो भाषा की पसंद को अनिवार्य करता है।

— जिम बाल्टर

Answer 6

अन्य पुस्तकालयों का उपयोग किए बिना, मैं निम्नलिखित कोड स्निपेट का उपयोग करना पसंद करता हूं:

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

यह विंडोज और POSIX- अनुरूप प्रणालियों के लिए क्रॉस-प्लेटफॉर्म का काम करता है।

Comments

क्या यह मैक पर काम करता है? मेरे पास एक मैक नहीं है, लेकिन मैं एक मैक को unistd.hभी शामिल करने में सक्षम होने की उम्मीद करूंगा । शायद पहले #ifdefखिड़कियां विशिष्ट होनी चाहिए?

— 20

Mac OSX POSIX- अनुरूप है।

— schaiba

Answer 7

PherricOxide द्वारा सुझाए गए लेकिन सी में

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

Comments

.c_str () एक C ++ फ़ंक्शन है। मुझे C ++ का पता नहीं है इसलिए मैंने एक C समकक्ष पोस्ट किया है।

— रेमन ला पिएत्रा

Answer 8

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

Comments

यदि आप वास्तव में ऐसा करने जा रहे हैं, तो बस "रिटर्न (बूल) फ़ाइल" का उपयोग करने के बजाय अगर / शाखा का उपयोग करें।

— निक हल्दीमन

सही मामले की स्थिति में फ़ाइल को बंद करना न भूलें। यह एक प्रकार का मेमोरी लीक है, यदि आप प्रोग्राम के पूरे रनटाइम के लिए फ़ाइल को खुला छोड़ते हैं, तो इसका उल्लेख नहीं करने के लिए यह आपकी फ़ाइल को लॉक कर सकता है ताकि आप यह जानने के बाद इसे पढ़ न सकें कि इसका अस्तित्व है: add: file.close () दूसरे को।

— बिल मूर

दूसरे विचार पर शायद आपको इसे स्पष्ट रूप से बंद करने की आवश्यकता नहीं है ... मैं भूल गया था कि ifstream एक RAII (संसाधन अधिग्रहण प्रारंभिक है) ... और खुद को साफ कर देगा क्योंकि यह विध्वंसक से दायरे से बाहर जाता है ... क्या क्या मैं कह सकता हूं ... मैं इन दिनों कचरा बीनने वाली भाषाओं से दिमाग लगा रहा हूं ...

— बिल मूर

@BillMoore आपकी दूसरी टिप्पणी सही है; इस पृष्ठ पर कई अन्य टिप्पणियों ने उल्लेख किया close()है कि आवश्यक नहीं है।

— कीथ एम

यह पहुंच की जांच करता है, अस्तित्व की नहीं। उदाहरण के लिए, यदि फ़ाइल मौजूद है, लेकिन एक्सेस अधिकारों के कारण एक्सेस नहीं किया जा सकता है, तो यह गलत तरीके से वापस आ जाएगा, यह दावा करते हुए कि फ़ाइल मौजूद नहीं है।

— SasQ

Answer 9

खिड़कियों के नीचे एक और 3 विकल्प:

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

Comments

OpenFile केवल ANSI है और 128 वर्णों तक सीमित है ।

— डेविड ब्रेमनर

GetFileAttributesसंस्करण मूल रूप से Windows में यह करने के लिए विहित तरीका है।

— फेलिक्स डोमबेक

मुझे पता है कि यह पुराना है, लेकिन उपयोगकर्ता के पास फ़ाइल को पढ़ने की क्षमता है, लेकिन 3 जी मामले में क्या होगा लेकिन फ़ाइल विशेषताओं को पढ़ने की अनुमति नहीं है?

— क्वेस्ट

Answer 10

तुम भी ऐसा कर सकते हैं bool b = std::ifstream('filename').good();। शाखा निर्देशों के बिना (जैसे यदि) इसे तेजी से प्रदर्शन करना होगा क्योंकि इसे हजारों बार कॉल करने की आवश्यकता होती है।

Comments

जैसा कि स्वीकृत उत्तर दिखाता है, यह असत्य है। किसी भी गंभीर संकलक शायद एक ही कोड है कि क्या आप में डाल उत्सर्जित करेगा अगर है या नहीं। सादे-सी वेरिएंट की तुलना में, ifstream ऑब्जेक्ट (भले ही स्टैक पर) अतिरिक्त ओवरहेड का निर्माण करता है।

— 20

Answer 11

यदि आपको किसी फ़ाइल और निर्देशिका के बीच अंतर करने की आवश्यकता है, तो निम्नलिखित पर विचार करें कि दोनों स्टेट का उपयोग करते हैं जो कि 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;
}

Answer 12

मुझे एक तेज़ फ़ंक्शन की आवश्यकता है जो यह जांच सके कि कोई फ़ाइल मौजूद है या नहीं और PherricOxide का उत्तर लगभग वही है जिसकी मुझे आवश्यकता है सिवाय इसके कि वह बूस्ट के प्रदर्शन की तुलना न करें: फाइलसिस्टम :: मौजूद है और खुले कार्य करता है। बेंचमार्क परिणामों से हम आसानी से देख सकते हैं कि:

• किसी फ़ाइल के मौजूद होने की जाँच करने के लिए स्टेटम फंक्शन का उपयोग करना सबसे तेज़ तरीका है। ध्यान दें कि मेरे परिणाम PherricOxide के उत्तर के अनुरूप हैं।

• बढ़ावा देने का प्रदर्शन :: filesystem :: मौजूद फ़ंक्शन स्टेट फ़ंक्शन के बहुत करीब है और यह पोर्टेबल भी है। मैं इस समाधान की सिफारिश करूंगा, अगर आपके पुस्तकालयों से बूस्ट लाइब्रेरी सुलभ है।

लिनक्स कर्नेल के साथ बेंचमार्क परिणाम 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();   

Answer 13

आप उपयोग कर सकते हैं std::ifstreamकी तरह funcion, is_open, failकोड (अदालत "खुला" का अर्थ है फ़ाइल मौजूद है या नहीं) नीचे के रूप में, उदाहरण के लिए:

इस उत्तर से उद्धृत

Answer 14

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

जहाँ Rआपका पथ-क्रम जैसी चीज़ों का क्रम है, और exists()भविष्य के std या वर्तमान बढ़ावा से है। यदि आप अपना स्वयं का रोल करते हैं, तो इसे सरल रखें,

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
}

Comments

PathFileExistsMAX_PATH(२६०) वर्णों तक सीमित है ; GetFileAttributesयह सीमा नहीं है।

— फेलिक्स डॉमबेक

GetFileAttributesMAX_PATH तक ही सीमित है। डॉक्स एक वर्कअराउंड का वर्णन करता है यदि आप पूर्ण पथ, यूनिकोड का उपयोग करते हैं, और पथ नाम के लिए एक विशेष उपसर्ग स्ट्रिंग प्रस्तुत करते हैं। मुझे लगता है कि हम वैसे भी विंडोज-विशिष्ट प्रतिक्रियाओं के साथ एक स्पर्शरेखा पर हैं।

— जॉन

GetFileAttributesWसीमा नहीं है।

— लॉरी स्टर्न

Answer 15

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

Comments

यह विन्सेंट द्वारा 4 साल पहले दिए गए उत्तर की तुलना में कम जानकारीपूर्ण है।

— जिम बेल्टर

C ++ में 17 फाइल सिस्टम अब प्रायोगिक नहीं है

— क्वेस्ट

Answer 16

MFC का उपयोग करना निम्नलिखित के साथ संभव है

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

जहाँ FileNameएक स्ट्रिंग है जो फ़ाइल को आप अस्तित्व के लिए जाँच रहे हैं

Answer 17

फ़ाइल मौजूद है या नहीं, इसकी जांच करने के लिए केवल एक तेज़ तरीका है और यदि आपके पास इसे पढ़ने की अनुमति है, तो C भाषा का उपयोग करना तेज़ है और C ++ में किसी भी संस्करण में भी उपयोग किया जा सकता है

हल : C में एक ऐसी लाइब्रेरी है, जिसके पास एक बाहरी (वैश्विक) पूर्णांक चर है, जिसे इरनो कहा जाता है, जिसमें एक संख्या होती है जिसका उपयोग त्रुटि के प्रकार को पहचानने के लिए किया जा सकता है।

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

Answer 18

हालाँकि, इसे करने के कई तरीके हैं, जो आपकी समस्या का सबसे कारगर समाधान है, शायद एक अच्छा तरीका ( जैसे ) की पूर्वनिर्मित विधि का उपयोग करना है । इस पद्धति से आप जांच सकते हैं कि आपके द्वारा निर्दिष्ट फ़ाइल मौजूद है या नहीं।

fstream file("file_name.txt");

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

मुझे उम्मीद है कि आपको यह काम का लगेगा।

Comments

यदि यह मौजूद नहीं है, तो यह कोड फ़ाइल बनाएगा, इसलिए परिणाम हमेशा सही रहेगा। आपको या तो ifstream का उपयोग करने की आवश्यकता है, या ओपनमोड पैरामीटर को सही ढंग से सेट करें।

— लुबो एंटोनोव