सी ++ में फ़ोल्डर को कैसे हटाएं?

Question

मैं C++ का उपयोग कर फ़ोल्डर को कैसे हटा सकता हूं?

यदि कोई क्रॉस-प्लेटफार्म तरीका मौजूद नहीं है, तो विंडोज, लिनक्स, मैक, आईओएस, एंड्रॉइड के सबसे लोकप्रिय ओएस के लिए इसे कैसे करें? क्या पॉसिक्स समाधान उन सभी के लिए काम करेगा?

Answer 1

सी ++ मानक निष्कासन() फ़ंक्शन को परिभाषित करता है, जो कार्यान्वयन के आधार पर फ़ोल्डर को हटा सकता है या नहीं हटा सकता है। यदि आपको आरएमडीआईआर() जैसे कार्यान्वयन विशिष्ट फ़ंक्शन का उपयोग करने की आवश्यकता नहीं है।

Answer 2

निर्देशिका खाली होना चाहिए और आपके प्रोग्राम यह

लेकिन समारोह कहा जाता rmdir क्या करेंगे यह

rmdir("C:/Documents and Settings/user/Desktop/itsme") 

Answer 3

निर्देशिका खाली होना चाहिए हटाने की अनुमतियां चाहिए।

BOOL RemoveDirectory(LPCTSTR lpPathName); 

Answer 4

यदि आप विंडोज का उपयोग कर रहे हैं, तो this link पर एक नज़र डालें। अन्यथा, आप अपने ओएस विशिष्ट संस्करण एपीआई की तलाश कर सकते हैं। मुझे नहीं लगता कि सी ++ इसे करने के लिए एक क्रॉस-प्लेटफ़ॉर्म तरीका के साथ आता है। अंत में, यह सी ++ का काम नहीं है, यह ओएस का काम है।

Answer 5

मैं दृढ़ता से Boost.FileSystem का उपयोग करने की सलाह देता हूं।

http://www.boost.org/doc/libs/1_38_0/libs/filesystem/doc/index.htm

आपके मामले में कि

boost::filesystem::remove_all(yourPath)

Answer 6

फ़ोल्डर हटाएं विंडोज (VisualC++) में शैल एपीआई का उपयोग नहीं (sub_folders और फ़ाइलें) हो सकता है, यह सबसे अच्छा काम कर नमूना है:

#include <string> 
#include <iostream> 

#include <windows.h> 
#include <conio.h> 


int DeleteDirectory(const std::string &refcstrRootDirectory, 
        bool    bDeleteSubdirectories = true) 
{ 
    bool   bSubdirectory = false;  // Flag, indicating whether 
               // subdirectories have been found 
    HANDLE   hFile;      // Handle to directory 
    std::string  strFilePath;     // Filepath 
    std::string  strPattern;     // Pattern 
    WIN32_FIND_DATA FileInformation;    // File information 


    strPattern = refcstrRootDirectory + "\\*.*"; 
    hFile = ::FindFirstFile(strPattern.c_str(), &FileInformation); 
    if(hFile != INVALID_HANDLE_VALUE) 
    { 
    do 
    { 
     if(FileInformation.cFileName[0] != '.') 
     { 
     strFilePath.erase(); 
     strFilePath = refcstrRootDirectory + "\\" + FileInformation.cFileName; 

     if(FileInformation.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
     { 
      if(bDeleteSubdirectories) 
      { 
      // Delete subdirectory 
      int iRC = DeleteDirectory(strFilePath, bDeleteSubdirectories); 
      if(iRC) 
       return iRC; 
      } 
      else 
      bSubdirectory = true; 
     } 
     else 
     { 
      // Set file attributes 
      if(::SetFileAttributes(strFilePath.c_str(), 
           FILE_ATTRIBUTE_NORMAL) == FALSE) 
      return ::GetLastError(); 

      // Delete file 
      if(::DeleteFile(strFilePath.c_str()) == FALSE) 
      return ::GetLastError(); 
     } 
     } 
    } while(::FindNextFile(hFile, &FileInformation) == TRUE); 

    // Close handle 
    ::FindClose(hFile); 

    DWORD dwError = ::GetLastError(); 
    if(dwError != ERROR_NO_MORE_FILES) 
     return dwError; 
    else 
    { 
     if(!bSubdirectory) 
     { 
     // Set directory attributes 
     if(::SetFileAttributes(refcstrRootDirectory.c_str(), 
           FILE_ATTRIBUTE_NORMAL) == FALSE) 
      return ::GetLastError(); 

     // Delete directory 
     if(::RemoveDirectory(refcstrRootDirectory.c_str()) == FALSE) 
      return ::GetLastError(); 
     } 
    } 
    } 

    return 0; 
} 


int main() 
{ 
    int   iRC     = 0; 
    std::string strDirectoryToDelete = "c:\\mydir"; 


    // Delete 'c:\mydir' without deleting the subdirectories 
    iRC = DeleteDirectory(strDirectoryToDelete, false); 
    if(iRC) 
    { 
    std::cout << "Error " << iRC << std::endl; 
    return -1; 
    } 

    // Delete 'c:\mydir' and its subdirectories 
    iRC = DeleteDirectory(strDirectoryToDelete); 
    if(iRC) 
    { 
    std::cout << "Error " << iRC << std::endl; 
    return -1; 
    } 

    // Wait for keystroke 
    _getch(); 

    return 0; 
} 

स्रोत: http://www.codeguru.com/forum/showthread.php?t=239271

Answer 7

// खिड़कियों के लिए:

#include <direct.h> 


if(_rmdir("FILEPATHHERE") != -1) 
{ 
    //success  
} else { 
    //failure 
} 

Answer 8

उपयोग SHFileOperation फ़ोल्डर को निकालना recursivelly

Answer 9

आप भी इस कोशिश कर सकते हैं यदि आप लिनक्स पर हैं:

system("rm -r path"); 

Answer 10

कोशिश उपयोग प्रणाली "rmdir -s -q file_to_delte" ।
यह फ़ोल्डर और इसमें सभी फाइलों को हटा देगा।

Answer 11

void remove_dir(char *path) 
{ 
     struct dirent *entry = NULL; 
     DIR *dir = NULL; 
     dir = opendir(path); 
     while(entry = readdir(dir)) 
     { 
       DIR *sub_dir = NULL; 
       FILE *file = NULL; 
       char abs_path[100] = {0}; 
       if(*(entry->d_name) != '.') 
       { 
         sprintf(abs_path, "%s/%s", path, entry->d_name); 
         if(sub_dir = opendir(abs_path)) 
         { 
           closedir(sub_dir); 
           remove_dir(abs_path); 
         } 
         else 
         { 
           if(file = fopen(abs_path, "r")) 
           { 
             fclose(file); 
             remove(abs_path); 
           } 
         } 
       } 
     } 
     remove(path); 
} 

Answer 12

मेरा स्वयं का कार्यान्वयन एचबी 0 के आधार पर है जो आपको प्रत्येक प्रदर्शन में फ़ाइलों की संख्या को थोड़ा प्रदर्शन बढ़ावा देने के साथ भी देखने की अनुमति देता है।

#include <string> 
#include <iostream> 
#include <cstdlib> 
#include <cstdio> 
#include <windows.h> 
#include <conio.h> 

union seperated { 
    struct { 
    unsigned int low; 
    unsigned int high; 
    } uint; 
    unsigned long long ull; 
}; 

unsigned long long num_dirs = 1; 
unsigned long long num_files = 0; 
seperated size_files; 

int DeleteDirectory(char* refRootDirectory);  //predeclare it 

int DeleteDirectory(char* refRootDirectory) { 
    HANDLE  hFile;    // Handle to directory 
    std::string strFilePath;   // Filepath 
    WIN32_FIND_DATA FileInformation; // File information 
    int  dwError;   // Folder deleting error 
    std::string strPattern;   // Pattern 

    strPattern = (std::string)(refRootDirectory) + "\\*.*"; 
    hFile = ::FindFirstFile(strPattern.c_str(), &FileInformation); 

    if(hFile != INVALID_HANDLE_VALUE) 
    { 
     do { 
      if(FileInformation.cFileName[0] != '.') { 
       strFilePath.erase(); 
       strFilePath = std::string(refRootDirectory) + "\\" + FileInformation.cFileName; 

       if(FileInformation.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { 
        DeleteDirectory((char*)strFilePath.c_str()); 

        dwError = ::GetLastError(); 
        if(dwError != ERROR_NO_MORE_FILES) { 
         std::cout << "!ERROR!: [[" << strFilePath.c_str() << "]]\n"; 
         return dwError; 
        } else { 
         // Set directory attributes 
         if(! ::SetFileAttributes(refRootDirectory,FILE_ATTRIBUTE_NORMAL)) { 
          std::cout << "!ERROR!: [[" << strFilePath.c_str() << "]]\n"; 
          return ::GetLastError(); 
         } 

         // Delete directory 
         if(! ::RemoveDirectory(refRootDirectory)) { 
          std::cout << "!ERROR!: [[" << strFilePath.c_str() << "]]\n"; 
          return ::GetLastError(); 
         } 
        } 

        ++num_dirs; 
       } else { 

        // Set file attributes 
        if(! ::SetFileAttributes(strFilePath.c_str(),FILE_ATTRIBUTE_NORMAL)) { 
         std::cout << "!ERROR!: [[" << strFilePath.c_str() << "]]\n"; 
         return ::GetLastError(); 
        } 

        // Delete file 
        if (! ::DeleteFile(strFilePath.c_str())) { 
         std::cout << "!ERROR!: [[" << strFilePath.c_str() << "]]\n"; 
         return ::GetLastError(); 
        } 

        size_files.ull  += FileInformation.nFileSizeLow; 
        size_files.uint.high += FileInformation.nFileSizeHigh; 

        ++num_files; 
       } 
      } 
     } while(::FindNextFile(hFile,&FileInformation)); 

     // Close handle 
     ::FindClose(hFile ); 
    } 

    return 0; 
} 

unsigned long long num_files_total=0; 
unsigned long long num_dirs_total=0; 
unsigned long long total_size_files=0; 

void my_del_directory(char* dir_name) { 
    int iRC = DeleteDirectory(dir_name); 
    //int iRC=0; 

    std::cout << "\"" << dir_name << "\"" 
      "\n Folders: " << num_dirs 
      << "\n Files: " << num_files 
      << "\n Size: " << size_files.ull << " Bytes"; 
    if(iRC) 
    { 
     std::cout << "\n!ERROR!: " << iRC; 
    } 
    std::cout << "\n\n"; 

    num_dirs_total += num_dirs; 
    num_files_total += num_files; 
    total_size_files += size_files.ull; 
    num_dirs = 1; 
    num_files = 0; 
    size_files.ull = 0ULL; 
    return; 
} 

int main(void) 
{ 
    size_files.ull = 0ULL; 

    my_del_directory((char*)"C:\Windows\temp"  ); 
     // This will clear out the System temporary directory on windows systems 

    std::cout << "\n\nResults" << "\nTotal Folders: " << num_dirs_total 
        << "\nTotal Files: " << num_files_total 
        << "\nTotal Size: " << total_size_files << " Bytes\n"; 

    return 0; 
} 

Answer 13

के साथ सी ++ 17 आप std::filesystem उपयोग कर सकते हैं सी ++ 14 std::experimental::filesystem में, पहले से ही उपलब्ध है। दोनों filesystem::remove() के उपयोग की अनुमति देते हैं।

सी ++ 17:

#include <filesystem> 
std::filesystem::path::remove("myEmptyDirectoryOrFile"); // Deletes empty directories or single files. 
std::filesystem::path::remove_all("myDirectory"); // Deletes one or more files recursively. 

सी ++ 14:

#include <experimental/filesystem> 
std::experimental::filesystem::path::remove("myDirectory"); 

नोट 1: उन कार्यों त्रुटि के मामले में filesystem_error फेंक देते हैं। यदि आप अपवादों को पकड़ने से बचना चाहते हैं, तो std::error_code के साथ दूसरे पैरामीटर के रूप में ओवरलोडेड वेरिएंट का उपयोग करें। जैसे

std::error_code errorCode; 
if (!std::filesystem::path::remove("myEmptyDirectoryOrFile", errorCode)) { 
    std::cout << errorCode.message() << std::endl; 
} 

नोट 2: रूपांतरण std::filesystem::path करने के लिए विभिन्न एन्कोडिंग से निहित होता है, ताकि आप filesystem::remove() को तार पारित कर सकते हैं।