স্ট্যান্ডার্ড সি ++ / সি ++ 11 / সি ব্যবহার করে কোনও ফাইল উপস্থিত রয়েছে কিনা তা পরীক্ষা করার দ্রুততম উপায়?

Question

আমি স্ট্যান্ডার্ড সি ++ 11, সি ++, বা সি-তে কোনও ফাইলের উপস্থিতি আছে কিনা তা যাচাই করার দ্রুততম উপায়টি খুঁজতে চাই I /* SOMETHING */নিম্নলিখিত ফাংশনের পরিবর্তে আমি কী লিখতে পারি ?

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

Comments

boost::filesystemব্যবহার মনে হচ্ছে stat()। (ডকুমেন্টেশন থেকে ধরে নেওয়া।) আমি মনে করি না আপনি এফএস কলগুলির জন্য খুব বেশি দ্রুত করতে পারবেন। আপনি কী করছেন তা দ্রুত করার উপায় হ'ল "হাজার হাজার ফাইলের দিকে তাকানো এড়ানো"।

— মিলিমুজ

টেকটিউ প্রশ্ন: আপনি কীভাবে জানবেন যে ফাইলটি আপনার বিদ্যমান () চেক এবং আপনার "এটিতে কিছু করা" এর মধ্যে লিঙ্কযুক্ত নয় ?

— পাইকক্রো

@ ফিলক্রো গুড পয়েন্ট, তবে অ্যাপ্লিকেশনগুলির মোটামুটি বিস্তৃত পরিসীমা রয়েছে যাতে এতো সঠিকতার প্রয়োজন হয় না। উদাহরণস্বরূপ git pushসম্ভবত প্রাথমিক নোংরা চেকের পরেও আপনি কাজের গাছটিকে স্পর্শ করছেন না তা নিশ্চিত করে বিরক্ত করে না।

— মিলিমুজ

'আমি কোনও সি / সি ++ প্রয়োগের কথা ভাবতে পারি না যা এর না থাকে' - উইন্ডোজ কোনও পসিক্স পরিবেশ সরবরাহ করে না।

— জিম বাল্টার

স্ট্যান্ড :: এর প্রবাহের

— MD XF

Answer 1

ঠিক আছে, আমি একসাথে একটি পরীক্ষা প্রোগ্রাম নিক্ষেপ করেছি যা এই পদ্ধতিগুলির প্রত্যেকটি ১০,০০,০০০ বার দৌড়েছিল, অর্ধেক ফাইল রয়েছে যা বিদ্যমান ছিল এবং অর্ধেক ফাইলগুলিতে নেই।

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

মোট সময়ের জন্য ১০,০০,০০০ কল চালুর জন্য ফলাফল পাঁচ রানেরও বেশি,

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

উপরের কোনও পদ্ধতি অস্তিত্বের জন্য যাচাই করে না, বরং অ্যাক্সেসযোগ্যতা। যদিও অস্তিত্বের জন্য যাচাই করার জন্য আমি একক মানের সি বা সি ++ উপায় জানি না।

— IInspectable

stat()মনে হচ্ছে অস্তিত্বের জন্য যাচাই করা হচ্ছে।

— el.pescado

এটি ব্যবহার করা যে কোনও ব্যক্তিকে মনে রাখতে হবে # অন্তর্ভুক্ত <sys / stat.h> অন্যথায় এটি ভুল স্ট্যাট ব্যবহার করার চেষ্টা করে।

— কটিয়ানী

আমি ifstream পদ্ধতিটির জন্য কল্পনা করি, f.close()ফাংশনটির শেষে এফ স্কোপের বাইরে যাওয়ার কারণে আপনার দরকার নেই । সুতরাং ব্লক return f.good()প্রতিস্থাপন করতে পারে if?

— ilent2

আপনি আসন্ন স্ট্যান্ডার্ড থেকে en.cppreferences.com/w/cpp/experimental/fs/exists / পরীক্ষার ব্যবহার করতে পারেন

— zahir

Answer 2

মন্তব্য: সি ++ ১৪ এ এবং ফাইল সিস্টেম টিএস শেষ হওয়ার সাথে সাথে এটি গৃহীত হবে, সমাধানটি ব্যবহার করা হবে:

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

এবং যেহেতু কেবল সি ++ 17, কেবলমাত্র:

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

Comments

ইতিমধ্যেই প্রাপ্তিসাধ্য Boost.Filesystem

— TemplateRex

এমএস ভিজ্যুয়াল স্টুডিও ২০১৩-তে এই ফাংশনটি 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

আমি এই টুকরো কোডটি ব্যবহার করি, এটি এখনও পর্যন্ত আমার সাথে ঠিক আছে। এটি সি ++ এর অনেক অভিনব বৈশিষ্ট্য ব্যবহার করে না:

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

Comments

তবে ফাইলটি অন্য কোনও প্রোগ্রাম দ্বারা লক করা থাকলে বা যদি ফাইলটিতে অ্যাক্সেস না থাকে তবে এটি ব্যর্থ হতে পারে।

— জেট

আপনার স্ট্রিমটি বন্ধ করার দরকার আছে?

— Mo0gles

@ মো0gles: ifstreamধ্বংসকারীকে প্রস্থান করার জন্য ডাকা is_file_existহবে এবং এটি প্রবাহ বন্ধ করবে close

— ইসহাক

সি ++ 11 হিসাবে আপনি বুল

— মুগেন

@ ওড়ওলোফাইলreturn std::ifstream(fileName);

— এম্লাই

Answer 4

এটি ফাইলগুলি কোথায় থাকে তার উপর নির্ভর করে। উদাহরণস্বরূপ, যদি সেগুলি সমস্ত একই ডিরেক্টরিতে অনুমিত হয় তবে আপনি সমস্ত ডিরেক্টরি এন্ট্রি একটি হ্যাশ টেবিলের মধ্যে পড়তে পারেন এবং তারপরে হ্যাশ টেবিলের বিপরীতে সমস্ত নাম পরীক্ষা করতে পারেন। এটি প্রতিটি সিস্টেমে পৃথকভাবে পরীক্ষা করার চেয়ে কিছু সিস্টেমে দ্রুত হতে পারে। স্বতন্ত্রভাবে প্রতিটি ফাইল চেক করার দ্রুততম পদ্ধতিটি আপনার সিস্টেমে নির্ভর করে ... আপনি যদি এএনএসআই সি লিখছেন তবে দ্রুততম উপায় হ'ল fopenকারণ এটিই একমাত্র উপায় (কোনও ফাইল উপস্থিত থাকতে পারে তবে খোলা যায় না তবে আপনি সম্ভবত সত্যই খোলার যোগ্য চান যদি আপনি "এটিতে কিছু করার দরকার")। সি ++, পসিক্স, উইন্ডোজ সবই অতিরিক্ত বিকল্প সরবরাহ করে।

আমি যখন এটি করছি তখন আমাকে আপনার প্রশ্নে কিছু সমস্যা চিহ্নিত করতে দিন। আপনি বলছেন যে আপনি দ্রুততম উপায় চান, এবং আপনার কাছে হাজার হাজার ফাইল রয়েছে, তবে তার পরে আপনি কোনও একটি ফাইল পরীক্ষা করার জন্য কোনও ফাংশনের কোডের জন্য জিজ্ঞাসা করেন (এবং সেই ফাংশনটি কেবল সি ++ তে বৈধ, সি নয়)। এটি XY সমস্যাটির কেস সমাধানের ক্ষেত্রে ... সম্পর্কে ধারণা নিয়ে আপনার প্রয়োজনীয়তার সাথে বিরোধিতা করে । আপনি "স্ট্যান্ডার্ড সি ++ 11 (বা) সি ++ (বা) সি" তেও বলছেন ... যা সব আলাদা, এবং এটিও গতির জন্য আপনার প্রয়োজনীয়তার সাথে সঙ্গতিপূর্ণ নয় ... দ্রুততম সমাধানটি কোডটির সাথে টেলিং জড়িত করবে লক্ষ্য সিস্টেম। প্রশ্নের অসঙ্গতি এই বিষয়টির দ্বারা হাইলাইট করা হয়েছে যে আপনি এমন একটি উত্তর গ্রহণ করেছেন যা সমাধান দেয় যা সিস্টেম-নির্ভর এবং মান সি বা সি ++ নয়।

Answer 5

যারা উত্সাহ চান তাদের জন্য:

 boost::filesystem::exists(fileName)

Comments

বুস্ট সাধারণত অত্যন্ত ধীর হয়।

— সার্জ রোগাচ

বেশিরভাগ অ্যাপ্লিকেশনগুলির জন্য কোনও ফাইল উপস্থিত রয়েছে যাচাই করা সমালোচনা নয়

— 916 তে অ্যাশপ্প করুন

উচ্চ পারফরম্যান্স অ্যাপ্লিকেশনটির সমস্ত দিকের অপ্টিমাইজেশনের প্রয়োজন হয় না। উদাহরণস্বরূপ, কমান্ড লাইন বা কনফিগার ফাইলটি পড়া জটিল হতে পারে এবং তার জন্য গতির প্রয়োজন পড়তে পারে না, যদিও অ্যাপ্লিকেশনটিতে নিজেই সি ++ এর কার্যকারিতা সুবিধা প্রয়োজন হতে পারে। এ জাতীয় ক্ষেত্রে বুস্ট এড়ানো চাকা পুনর্বিন্যাস গঠন করে, যা অ্যান্টি-প্যাটার্ন তালিকায় উচ্চ।

— evoskuil

@ সার্জরোগাচ বুস্ট :: ফাইলসিস্টেম :: বিদ্যমান অত্যন্ত ধীর নয়। বিস্তারিত তথ্যের জন্য আমার মানদণ্ডের ফলাফলগুলি দেখুন।

— হ্যাঙ্গপিত

"বুস্টটি সাধারণত অত্যন্ত ধীর" - এটি মিথ্যা, এবং দাবিটির ক্ষেত্র কী তা এমনকি এটিও পরিষ্কার নয় ... বুস্টে বিভিন্ন লেখক অনেকগুলি প্যাকেজ ধারণ করে তবে উচ্চমানের জন্য এটি পরীক্ষিত। "বেশিরভাগ অ্যাপ্লিকেশনগুলির জন্য কোনও ফাইলের উপস্থিতি পরীক্ষা করা সমালোচনা হয় না" - খুব বেশি সংখ্যক ফাইল পরীক্ষা করার কারণে ওপি বিশেষত গতি চেয়েছিল। "যদি পারফরম্যান্স সমালোচনা না করে, তবে সি ++ ব্যবহার করারও কোনও অর্থ নেই" - অন্য একটি ভুল মন্তব্য (এবং বিষয় ছাড়াই)। সর্বাধিক সফ্টওয়্যার লেখা আছে শপ এবং একটি অংশ সিস্টেম যে ম্যান্ডেট ভাষা পছন্দ।

— জিম বাল্টার

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

এটি উইন্ডোজ এবং পসিক্স-কমপ্লায়েন্ট সিস্টেমগুলির জন্য ক্রস প্ল্যাটফর্মের কাজ করে।

Comments

এই ম্যাক কাজ করে? আমার কাছে ম্যাক নেই, তবে আমি ম্যাকটিও অন্তর্ভুক্ত করতে সক্ষম হবে বলে আশা করব unistd.h। প্রথমটি #ifdefকি উইন্ডোজ নির্দিষ্ট হওয়া উচিত?

— ম্যাথ

ম্যাক ওএসএক্স পসিএক্স-সম্মতিযুক্ত l

— স্কাইবা

Answer 7

পেরিকঅক্সাইড দ্বারা প্রস্তাবিত একই কিন্তু সি তে

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

Comments

.c_str () একটি সি ++ ফাংশন। আমি সি ++ জানি না তাই আমি একটি সি সমতুল্য পোস্ট করেছি।

— রামন লা পিয়েটরা

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

আপনি যদি সত্যিই এটি করতে যাচ্ছেন তবে একটি / অন্য শাখা ব্যবহার না করে কেবল "রিটার্ন (বুল) ফাইল" করুন।

— নিক হালদিমন

সত্যিকারের ক্ষেত্রে ফাইলটি বন্ধ করতে ভুলবেন না। প্রোগ্রামটির পুরো রানটাইমের জন্য ফাইলটি উন্মুক্ত রেখে দেওয়া থাকলে এটি এক ধরণের মেমরি ফাঁস, এটি উল্লেখ না করে এটি আপনার ফাইলটিকে লক করতে পারে যাতে এটি উপস্থিত রয়েছে তা জানার পরে আপনি এটি পড়তে পারবেন না .. যোগ করুন: ফাইল.close () দ্বিতীয় থেকে দ্বিতীয়।

— বিল মুর

দ্বিতীয় ভাবাতে সম্ভবত আপনার এটিকে স্পষ্টভাবে বন্ধ করার দরকার নেই ... আমি ভুলে গিয়েছিলাম যে যদি আইফ্রিমিটি একটি আরএআইআই হয় (রিসোর্স অ্যাকুইজিশন ইশ ইনিশিয়েলাইজেশন) ... এবং এটি ডেস্ট্রাক্টরের সুযোগের বাইরে চলে যাওয়ার সাথে সাথে নিজেকে পরিষ্কার করে দেবে ... কী আমি কি বলতে পারি ... আজকাল আমি আবর্জনা সংগ্রহকারী ভাষায় ব্রেইন ওয়াশ হয়েছি ...

— বিল মুর

@ বিলমুর আপনার দ্বিতীয় মন্তব্যটি সঠিক; এই পৃষ্ঠায় অন্যান্য অনেক মন্তব্য উল্লেখ close()করা প্রয়োজন নয়।

— কিথ এম

এটি অ্যাক্সেসযোগ্যতা পরীক্ষা করে, অস্তিত্ব নয়। উদাহরণস্বরূপ, যদি ফাইলটি বিদ্যমান থাকে তবে অ্যাক্সেস অধিকারের কারণে অ্যাক্সেস করা যায় না, এটি ভুলভাবে দাবী করে যে ফাইলটির অস্তিত্ব নেই।

— সাসকিউ

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

ওপেনফিলটি কেবল এএনএসআই এবং 128 টি অক্ষরের মধ্যে সীমাবদ্ধ ।

— ডেভিড ব্রেমনার

GetFileAttributesসংস্করণ মূলত Windows এ এটা করতে ক্যানোনিকাল উপায়।

— ফেলিক্স ডমবাক

আমি জানি এটি পুরানো তবে 3 য় ক্ষেত্রে কী ঘটবে যখন ব্যবহারকারী ফাইলটি পড়ার ক্ষমতা রাখে তবে ফাইলের বৈশিষ্ট্যগুলি পড়তে দেওয়া হয় না?

— কোয়েস্ট

Answer 10

আপনিও করতে পারেন bool b = std::ifstream('filename').good();। শাখার নির্দেশাবলী ছাড়াই (যেমন যদি) এটি দ্রুত সঞ্চালন করতে হবে কারণ এটি হাজার বার বলা প্রয়োজন।

Comments

যেমন গৃহীত উত্তরগুলি দেখায়, এটি অসত্য। কোন গুরুতর কম্পাইলার সম্ভবত একই কোড কিনা রাখা নির্গত হবে যদি বা না। প্লেইন-সি ভেরিয়েন্টের সাথে তুলনা করে, ifstream অবজেক্ট (এমনকি স্ট্যাকের উপর দিয়ে) নির্মাণে অতিরিক্ত ওভারহেড জড়িত।

— মাইনক্সিউ

Answer 11

যদি আপনাকে কোনও ফাইল এবং ডিরেক্টরিগুলির মধ্যে পার্থক্য করতে হয়, নিম্নলিখিত দুটি বিবেচনা করুন যা উভয় স্ট্যাট ব্যবহার করে যা দ্রুততম স্ট্যান্ডার্ড সরঞ্জামটি ফেরিকঅক্সাইড দ্বারা প্রদর্শিত হিসাবে দেখায়:

#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

আমার একটি দ্রুত ফাংশন প্রয়োজন যা পরীক্ষা করতে পারে যে কোনও ফাইল উপস্থিত আছে কিনা এবং ফেরিকক্সাইডের উত্তরটি আমার প্রায় যা প্রয়োজন তা ছাড়া এটি বুস্ট :: ফাইলসিস্টেম :: এর উপস্থিতি এবং ওপেন ফাংশনগুলির তুলনা করে না except মাপদণ্ডের ফলাফলগুলি থেকে আমরা সহজেই এটি দেখতে পারি:

• স্ট্যাট ফাংশনটি ব্যবহার করা কোনও ফাইলের উপস্থিতি আছে কিনা তা যাচাই করার দ্রুততম উপায়। নোট করুন যে আমার ফলাফলগুলি ফেরিকঅক্সাইডের উত্তরের সাথে সামঞ্জস্যপূর্ণ।

• বুস্ট :: ফাইল সিস্টেম :: এর উপস্থিতি কার্যকারিতাটি স্ট্যাট ফাংশনের খুব কাছে এবং এটি বহনযোগ্যও। যদি আপনার কোড থেকে বুস্ট গ্রন্থাগারগুলি অ্যাক্সেসযোগ্য হয় তবে আমি এই সমাধানটি সুপারিশ করব।

লিনাক্স কার্নেল ৪.১.0.০ এবং জিসিসি-7.৩ সহ বেঞ্চমার্কের ফলাফল:

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, ফানসিওনের মতো is_open, failউদাহরণস্বরূপ নীচের কোড হিসাবে (cout "ওপেন" অর্থ ফাইলের অস্তিত্ব আছে কি নেই):

এই উত্তর থেকে উদ্ধৃত

Answer 14

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
}

Comments

PathFileExistsMAX_PATH(260) অক্ষরের মধ্যে সীমাবদ্ধ ; GetFileAttributesএই সীমাবদ্ধতা নেই।

— ফেলিক্স ডমব্যাক

GetFileAttributesপাশাপাশি MAX_PATH এর মধ্যেও সীমাবদ্ধ। আপনি যদি নিখুঁত পাথ, ইউনিকোড ব্যবহার করেন এবং পথের নামের সাথে একটি বিশেষ উপসর্গের স্ট্রিং প্রিন্ট করেন তবে ডকসগুলি একটি কার্যবিধির বর্ণনা দেয় । আমি মনে করি আমরা যাইহোক উইন্ডোজ-নির্দিষ্ট প্রতিক্রিয়াগুলির সাথে একটি স্পর্শকাতর বন্ধ।

— জন

GetFileAttributesWসীমাবদ্ধতা নেই।

— লরি স্টার্ন

Answer 15

সি ++ 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 বছর আগে ভিনসেন্টের দেওয়া উত্তরের চেয়ে এটি কম তথ্যবহুল।

— জিম বাল্টার

সি ++ এ 17 ফাইল সিস্টেম এখন আর পরীক্ষামূলক নয়

— কোয়েস্ট

Answer 16

এমএফসি ব্যবহার করে নিম্নলিখিতগুলি দিয়ে এটি সম্ভব

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

FileNameআপনি উপস্থিত থাকার জন্য যাচাই করছেন এমন ফাইলটি উপস্থাপন করে এমন স্ট্রিং কোথায়

Answer 17

ফাইলটি বিদ্যমান কিনা তা যাচাই করার জন্য কেবলমাত্র একটি দ্রুত উপায় আছে এবং যদি আপনার এটি পড়ার অনুমতি থাকে তবে সি ভাষার ইচ্ছাটি দ্রুত ব্যবহার করা যায় এবং সি +++ এর যে কোনও সংস্করণেও এটি ব্যবহার করা যেতে পারে

সমাধান : সিতে একটি গ্রন্থাগার রয়েছে এরনো। এর একটি বহিরাগত (গ্লোবাল) পূর্ণসংখ্যা ভেরিয়েবল রয়েছে যার মধ্যে এর্নো বলা হয় যার মধ্যে এমন একটি সংখ্যা রয়েছে যা ত্রুটির প্রকারটি সনাক্ত করতে ব্যবহার করা যেতে পারে

    #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 এর পূর্বনির্ধারিত পদ্ধতি যেমন ভাল () ব্যবহার করা । এই পদ্ধতির সাহায্যে আপনি যা নির্দিষ্ট করেছেন তা ফাইল উপস্থিত আছে কি নেই তা পরীক্ষা করে দেখতে পারেন।

fstream file("file_name.txt");

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

আশা করি এটি আপনার কাজে লাগবে।

Comments

এই কোডটি যদি ফাইলটি না থাকে তবে এটি তৈরি করবে, ফলস্বরূপ সর্বদা সত্য হবে। আপনাকে হয় ifstream ব্যবহার করতে হবে, বা ওপেনমোড প্যারামিটারটি সঠিকভাবে সেট করতে হবে।

— লুবো আন্তোনভ