Come eliminare una cartella in C ++?

Come posso cancellare una cartella usando C ++?

Se non esiste un modo multipiattaforma, allora come farlo per i sistemi operativi più popolari: Windows, Linux, Mac, iOS, Android? Una soluzione POSIX funzionerebbe per tutti loro?

Consiglio vivamente di usare Boost.FileSystem.

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

Nel tuo caso sarebbe

boost :: filesystem :: remove_all (yourpath)

Elimina cartella (sottocartelle e file) in Windows (VisualC ++) che non utilizza API Shell, questo è il miglior esempio di lavoro:

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

Fonte: http://www.codeguru.com/forum/showthread.php?t=239271

La directory dovrebbe essere vuota.

 BOOL RemoveDirectory( LPCTSTR lpPathName ); 

Utilizzare SHFileOperation per rimuovere la cartella in modo ricorsivo

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

Con C ++ 17 puoi usare std::filesystem , in C ++ 14 std::experimental::filesystem è già disponibile. Entrambi consentono l’uso di filesystem::remove() .

C ++ 17:

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

C ++ 14:

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

Nota 1: Queste funzioni lanciano filesystem_error in caso di errori. Se vuoi evitare di catturare eccezioni, usa le varianti sovraccaricate con std::error_code come secondo parametro. Per esempio

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

Nota 2: la conversione in std::filesystem::path implicita da diverse codifiche, quindi è ansible passare stringhe a filesystem::remove() .

La directory deve essere vuota e il tuo programma deve disporre delle autorizzazioni per eliminarlo

ma la funzione chiamata rmdir lo farà

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

Puoi anche provare questo se sei su linux:

 system("rm -r path"); 

Lo standard C ++ definisce la funzione remove (), che può o non può eliminare una cartella, a seconda dell’implementazione. In caso contrario, è necessario utilizzare una funzione specifica di implementazione come rmdir ().

// per windows:

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

Prova ad usare il sistema ” rmdir -s -q file_to_delte “.
Questo cancellerà la cartella e tutti i file in essa contenuti.

La mia implementazione basata su hB0 consente anche di visualizzare il numero di file in ogni cartella con un piccolo incremento di prestazioni.

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

Per Linux (ho corretto bug nel codice sopra):

 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 new char[256]; if ((*(entry->d_name) != '.') || ((strlen(entry->d_name) > 1) && (entry->d_name[1] != '.'))) { 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); } } } delete[] abs_path; } remove(path); } 

Per windows:

 void remove_dir(const wchar_t* folder) { std::wstring search_path = std::wstring(folder) + _T("/*.*"); std::wstring s_p = std::wstring(folder) + _T("/"); WIN32_FIND_DATA fd; HANDLE hFind = ::FindFirstFile(search_path.c_str(), &fd); if (hFind != INVALID_HANDLE_VALUE) { do { if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { if (wcscmp(fd.cFileName, _T(".")) != 0 && wcscmp(fd.cFileName, _T("..")) != 0) { remove_dir((wchar_t*)(s_p + fd.cFileName).c_str()); } } else { DeleteFile((s_p + fd.cFileName).c_str()); } } while (::FindNextFile(hFind, &fd)); ::FindClose(hFind); _wrmdir(folder); } } 

Se stai usando Windows, dai un’occhiata a questo link . Altrimenti, puoi cercare la tua versione specifica del sistema operativo. Non penso che C ++ abbia un modo multipiattaforma per farlo. Alla fine, non è il lavoro di C ++, è il lavoro del sistema operativo.