Comment puis-je obtenir la liste des fichiers dans un répertoire en utilisant C ou C ++?

Je pense que l’extrait ci-dessous peut être utilisé pour lister tous les fichiers.

 #include  #include  #include  static void list_dir(const char *path) { struct dirent *entry; DIR *dir = opendir(path); if (dir == NULL) { return; } while ((entry = readdir(dir)) != NULL) { printf("%s\n",entry->d_name); } closedir(dir); } 

Voici la structure du struct dirent

 struct dirent { ino_t d_ino; /* inode number */ off_t d_off; /* offset to the next dirent */ unsigned short d_reclen; /* length of this record */ unsigned char d_type; /* type of file */ char d_name[256]; /* filename */ }; 

Essayer de booster la méthode x-platform

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

ou utilisez simplement les fichiers de votre système d’exploitation.

Découvrez cette classe qui utilise l’api win32. Construisez simplement une instance en fournissant le foldername de foldername depuis lequel vous souhaitez que la liste appelle la méthode getNextFile pour obtenir le filename de filename suivant dans le répertoire. Je pense qu’il a besoin de windows.h et de stdio.h .

 class FileGetter{ WIN32_FIND_DATAA found; HANDLE hfind; char folderstar[255]; int chk; public: FileGetter(char* folder){ sprintf(folderstar,"%s\\*.*",folder); hfind = FindFirstFileA(folderstar,&found); //skip . FindNextFileA(hfind,&found); } int getNextFile(char* fname){ //skips .. when called for the first time chk=FindNextFileA(hfind,&found); if (chk) strcpy(fname, found.cFileName); return chk; } }; 

Manuel GNU FTW

http://www.gnu.org/software/libc/manual/html_node/Simple-Directory-Lister.html#Simple-Directory-Lister

En outre, parfois, il est bon d’aller directement à la source (jeu de mots). Vous pouvez apprendre beaucoup en regardant les entrailles de certaines des commandes les plus courantes sous Linux. J’ai mis en place un simple miroir des coreutils de GNU sur github (pour la lecture).

https://github.com/homer6/gnu_coreutils/blob/master/src/ls.c

Peut-être que cela ne concerne pas Windows, mais un certain nombre de cas d’utilisation de variantes Unix peuvent être obtenus en utilisant ces méthodes.

J’espère que cela pourra aider…

 char **getKeys(char *data_dir, char* tablename, int *num_keys) { char** arr = malloc(MAX_RECORDS_PER_TABLE*sizeof(char*)); int i = 0; for (;i < MAX_RECORDS_PER_TABLE; i++) arr[i] = malloc( (MAX_KEY_LEN+1) * sizeof(char) ); char *buf = (char *)malloc( (MAX_KEY_LEN+1)*sizeof(char) ); snprintf(buf, MAX_KEY_LEN+1, "%s/%s", data_dir, tablename); DIR* tableDir = opendir(buf); struct dirent* getInfo; readdir(tableDir); // ignore '.' readdir(tableDir); // ignore '..' i = 0; while(1) { getInfo = readdir(tableDir); if (getInfo == 0) break; strcpy(arr[i++], getInfo->d_name); } *(num_keys) = i; return arr; } 

J’espère que ce code vous aidera.

 #include  #include  #include  #include  using namespace std; ssortingng wchar_t2ssortingng(const wchar_t *wchar) { ssortingng str = ""; int index = 0; while(wchar[index] != 0) { str += (char)wchar[index]; ++index; } return str; } wchar_t *ssortingng2wchar_t(const ssortingng &str) { wchar_t wchar[260]; int index = 0; while(index < str.size()) { wchar[index] = (wchar_t)str[index]; ++index; } wchar[index] = 0; return wchar; } vector listFilesInDirectory(ssortingng directoryName) { WIN32_FIND_DATA FindFileData; wchar_t * FileName = ssortingng2wchar_t(directoryName); HANDLE hFind = FindFirstFile(FileName, &FindFileData); vector listFileNames; listFileNames.push_back(wchar_t2ssortingng(FindFileData.cFileName)); while (FindNextFile(hFind, &FindFileData)) listFileNames.push_back(wchar_t2ssortingng(FindFileData.cFileName)); return listFileNames; } void main() { vector listFiles; listFiles = listFilesInDirectory("C:\\*.txt"); for each (ssortingng str in listFiles) cout << str << endl; } 

Cette implémentation réalise votre objective, en remplissant dynamicment un tableau de chaînes avec le contenu du répertoire spécifié.

 int exploreDirectory(const char *dirpath, char ***list, int *numItems) { struct dirent **direntList; int i; errno = 0; if ((*numItems = scandir(dirpath, &direntList, NULL, alphasort)) == -1) return errno; if (!((*list) = malloc(sizeof(char *) * (*numItems)))) { fprintf(stderr, "Error in list allocation for file list: dirpath=%s.\n", dirpath); exit(EXIT_FAILURE); } for (i = 0; i < *numItems; i++) { (*list)[i] = stringDuplication(direntList[i]->d_name); } for (i = 0; i < *numItems; i++) { free(direntList[i]); } free(direntList); return 0; } 

Cela fonctionne pour moi. Je suis désolé si je ne peux pas me souvenir de la source. C’est probablement une page de manuel.

 #include  int AnalizeDirectoryElement (const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf) { if (tflag == FTW_F) { std::ssortingng strFileName(fpath); DoSomethingWith(strFileName); } return 0; } void WalkDirectoryTree (const char * pchFileName) { int nFlags = 0; if (nftw(pchFileName, AnalizeDirectoryElement, 20, nFlags) == -1) { perror("nftw"); } } int main() { WalkDirectoryTree("some_dir/"); } 

Vous pouvez obtenir tous les fichiers directs dans votre répertoire racine en utilisant std :: experimental :: filesystem :: directory_iterator (). Ensuite, lisez le nom de ces chemins.

 #include  #include  #include  #include  using namespace std; namespace fs = std::experimental::filesystem; void ShowListFile(ssortingng path) { for(auto &p: fs::directory_iterator(path)) /*get directory */ cout< 

Le système l’appelle!

 system( "dir /b /s /ad * > file_names.txt" ); 

Ensuite, lisez simplement le fichier.

EDIT: Cette réponse doit être considérée comme un hack, mais elle fonctionne vraiment (bien que de manière spécifique à une plate-forme) si vous n’avez pas access à des solutions plus élégantes.

Réponse Shreevardhan fonctionne très bien. Mais si vous voulez l’utiliser dans c ++ 14, créez simplement un namespace fs = experimental::filesystem; modification namespace fs = experimental::filesystem;

c’est à dire,

 #include  #include  #include  using namespace std; namespace fs = experimental::filesystem; int main() { ssortingng path = "C:\\splits\\"; for (auto & p : fs::directory_iterator(path)) cout << p << endl; int n; cin >> n; } 

Les fichiers et sous répertoires d’un répertoire étant généralement stockés dans une arborescence, une méthode intuitive consiste à utiliser l’algorithme DFS pour parcourir récursivement chacun d’entre eux. Voici un exemple du système d’exploitation Windows en utilisant les fonctions de fichiers de base dans io.h. Vous pouvez remplacer ces fonctions sur une autre plate-forme. Ce que je veux exprimer, c’est que l’idée de base de DFS répond parfaitement à ce problème.

 #include #include #include using namespace std; void TraverseFilesUsingDFS(const ssortingng& folder_path){ _finddata_t file_info; ssortingng any_file_pattern = folder_path + "\\*"; intptr_t handle = _findfirst(any_file_pattern.c_str(),&file_info); //If folder_path exsist, using any_file_pattern will find at least two files "." and "..", //of which "." means current dir and ".." means parent dir if (handle == -1){ cerr << "folder path not exist: " << folder_path << endl; exit(-1); } //iteratively check each file or sub_directory in current folder do{ string file_name=file_info.name; //from char array to string //check whtether it is a sub direcotry or a file if (file_info.attrib & _A_SUBDIR){ if (file_name != "." && file_name != ".."){ string sub_folder_path = folder_path + "\\" + file_name; TraverseFilesUsingDFS(sub_folder_path); cout << "a sub_folder path: " << sub_folder_path << endl; } } else cout << "file name: " << file_name << endl; } while (_findnext(handle, &file_info) == 0); // _findclose(handle); } 

Cette réponse devrait fonctionner pour les utilisateurs Windows qui ont des difficultés à utiliser Visual Studio avec l’une des autres réponses.

1. Téléchargez le fichier dirent.h à partir de la page github. Mais mieux vaut simplement utiliser le fichier Raw dirent.h et suivre mes étapes ci-dessous (c’est comme ça que je l’ai fait fonctionner).

   Page Github pour dirent.h pour Windows: page Github pour dirent.h

   Fichier de Dirent brut: fichier dirent.h brut

2. Accédez à votre projet et Ajouter un nouvel élément ( Ctrl + Maj + A ). Ajoutez un fichier d’en-tête (.h) et nommez-le dirent.h.

3. Collez le code de fichier Raw dirent.h dans votre en-tête.

4. Inclure “dirent.h” dans votre code.

5. Placez la void filefinder() ci-dessous dans votre code et appelez-la à partir de votre fonction main ou modifiez-la comme vous voulez l’utiliser.

    #include  #include  #include "dirent.h" ssortingng path = "C:/folder"; //Put a valid path here for folder void filefinder() { DIR *directory = opendir(path.c_str()); struct dirent *direntStruct; if (directory != NULL) { while (direntStruct = readdir(directory)) { printf("File Name: %s\n", direntStruct->d_name); //If you are using  //std::cout << direntStruct->d_name << std::endl; //If you are using  } } closedir(directory); } 

Cela a fonctionné pour moi. Il écrit un fichier avec juste les noms (pas de chemin) de tous les fichiers. Ensuite, il lit ce fichier txt et l’imprime pour vous.

 void DisplayFolderContent() { system("dir /n /b * > file_names.txt"); char ch; std::fstream myStream("file_names.txt", std::fstream::in); while (myStream.get(ch)) { std::cout << ch; } }