Как получить список файлов в каталоге с помощью C или С++?

Как определить список файлов в каталоге из моего кода C или C++?

Мне не разрешено выполнять команду ls и анализировать результаты из моей программы.

Ответ 1

В небольших и простых задачах я не использую boost, я использую dirent.h, который также доступен для windows:

DIR *dir;
struct dirent *ent;
if ((dir = opendir ("c:\\src\\")) != NULL) {
  /* print all the files and directories within directory */
  while ((ent = readdir (dir)) != NULL) {
    printf ("%s\n", ent->d_name);
  }
  closedir (dir);
} else {
  /* could not open directory */
  perror ("");
  return EXIT_FAILURE;
}

Это всего лишь небольшой заголовочный файл, который выполняет большинство простых задач без использования большого подхода на основе шаблонов, такого как boost (без обид, мне нравится boost!).

Автор слоя совместимости окон - Тони Ронкко. В Unix это стандартный заголовок.

ОБНОВЛЕНИЕ 2017:

В С++ 17 теперь есть официальный способ перечисления файлов вашей файловой системы: std::filesystem. Ниже приведен отличный ответ от Shreevardhan с этим исходным кодом:

#include <string>
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

int main()
{
    std::string path = "/path/to/directory";
    for (const auto & entry : fs::directory_iterator(path))
        std::cout << entry.path() << std::endl;
}

Ответ 2

С++ 17 теперь имеет std::filesystem::directory_iterator, который можно использовать как

#include <string>
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

int main() {
    std::string path = "/path/to/directory";
    for (const auto & entry : fs::directory_iterator(path))
        std::cout << entry.path() << std::endl;
}

Кроме того, std::filesystem::recursive_directory_iterator также может перебирать подкаталоги.

Ответ 3

К сожалению, стандарт C++ не определяет стандартный способ работы с файлами и папками таким образом.

Поскольку кроссплатформенного способа не существует, лучшим кроссплатформенным способом является использование библиотеки, такой как модуль файловой системы boost.

Кроссплатформенный метод повышения:

Следующая функция, учитывая путь к каталогу и имя файла, рекурсивно ищет в каталоге и его подкаталогах имя файла, возвращая bool, а в случае успеха - путь к найденному файлу.

bool find_file(const path & dir_path,         // in this directory,
               const std::string & file_name, // search for this name,
               path & path_found)             // placing path here if found
{
    if (!exists(dir_path)) 
        return false;

    directory_iterator end_itr; // default construction yields past-the-end

    for (directory_iterator itr(dir_path); itr != end_itr; ++itr)
    {
        if (is_directory(itr->status()))
        {
            if (find_file(itr->path(), file_name, path_found)) 
                return true;
        }
        else if (itr->leaf() == file_name) // see below
        {
            path_found = itr->path();
            return true;
        }
    }
    return false;
}

Источник со страницы поддержки, упомянутой выше.

Для систем на основе Unix/Linux:

Вы можете использовать opendir/readdir/closedir.

Пример кода, который ищет в каталоге запись "name":

len = strlen(name);
dirp = opendir(".");
while ((dp = readdir(dirp)) != NULL)
        if (dp->d_namlen == len && !strcmp(dp->d_name, name)) {
                (void)closedir(dirp);
                return FOUND;
        }
(void)closedir(dirp);
return NOT_FOUND;

Исходный код с указанных выше страниц руководства.

Для систем на базе Windows:

Вы можете использовать функции Wina API FindFirstFile/FindNextFile/FindClose.

В следующем примере C++ показано минимальное использование FindFirstFile.

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

void _tmain(int argc, TCHAR *argv[])
{
   WIN32_FIND_DATA FindFileData;
   HANDLE hFind;

   if( argc != 2 )
   {
      _tprintf(TEXT("Usage: %s [target_file]\n"), argv[0]);
      return;
   }

   _tprintf (TEXT("Target file is %s\n"), argv[1]);
   hFind = FindFirstFile(argv[1], &FindFileData);
   if (hFind == INVALID_HANDLE_VALUE) 
   {
      printf ("FindFirstFile failed (%d)\n", GetLastError());
      return;
   } 
   else 
   {
      _tprintf (TEXT("The first file found is %s\n"), 
                FindFileData.cFileName);
      FindClose(hFind);
   }
}

Исходный код с указанных выше страниц MSDN.

Ответ 4

Одной функции достаточно, вам не нужно использовать стороннюю библиотеку (для Windows).

#include <Windows.h>

vector<string> get_all_files_names_within_folder(string folder)
{
    vector<string> names;
    string search_path = folder + "/*.*";
    WIN32_FIND_DATA fd; 
    HANDLE hFind = ::FindFirstFile(search_path.c_str(), &fd); 
    if(hFind != INVALID_HANDLE_VALUE) { 
        do { 
            // read all (real) files in current folder
            // , delete '!' read other 2 default folder . and ..
            if(! (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) {
                names.push_back(fd.cFileName);
            }
        }while(::FindNextFile(hFind, &fd)); 
        ::FindClose(hFind); 
    } 
    return names;
}

PS: как упоминалось @Sebastian, вы можете изменить *.* на *.ext, чтобы получить только EXT файлы (т.е. определенного типа) в этом каталоге.

Ответ 5

Для решения только C, пожалуйста, проверьте это. Для этого требуется только дополнительный заголовок:

https://github.com/cxong/tinydir

tinydir_dir dir;
tinydir_open(&dir, "/path/to/dir");

while (dir.has_next)
{
    tinydir_file file;
    tinydir_readfile(&dir, &file);

    printf("%s", file.name);
    if (file.is_dir)
    {
        printf("/");
    }
    printf("\n");

    tinydir_next(&dir);
}

tinydir_close(&dir);

Некоторые преимущества перед другими вариантами:

Он переносится - обертывает POSIX dirent и Windows FindFirstFile
Он использует readdir_r где доступно, что означает, что он (обычно) threadsafe
Поддерживает Windows UTF-16 через те же макросы UNICODE
Это C90, поэтому даже очень древние компиляторы могут его использовать

Ответ 6

Я рекомендую использовать glob с помощью этой многоразовой обертки. Он генерирует vector<string>, соответствующий пути файла, которые соответствуют шаблону glob:

#include <glob.h>
#include <vector>
using std::vector;

vector<string> globVector(const string& pattern){
    glob_t glob_result;
    glob(pattern.c_str(),GLOB_TILDE,NULL,&glob_result);
    vector<string> files;
    for(unsigned int i=0;i<glob_result.gl_pathc;++i){
        files.push_back(string(glob_result.gl_pathv[i]));
    }
    globfree(&glob_result);
    return files;
}

который затем может быть вызван с обычным шаблоном шаблона системы, например:

vector<string> files = globVector("./*");

Ответ 7

Вот очень простой код в C++11 с использованием библиотеки boost::filesystem для получения имен файлов в каталоге (исключая имена папок):

#include <string>
#include <iostream>
#include <boost/filesystem.hpp>
using namespace std;
using namespace boost::filesystem;

int main()
{
    path p("D:/AnyFolder");
    for (auto i = directory_iterator(p); i != directory_iterator(); i++)
    {
        if (!is_directory(i->path())) //we eliminate directories
        {
            cout << i->path().filename().string() << endl;
        }
        else
            continue;
    }
}

Вывод похож:

file1.txt
file2.dat

Ответ 8

Почему бы не использовать glob()?

#include <glob.h>

glob_t glob_result;
glob("/your_directory/*",GLOB_TILDE,NULL,&glob_result);
for(unsigned int i=0; i<glob_result.gl_pathc; ++i){
  cout << glob_result.gl_pathv[i] << endl;
}

Ответ 9

Я думаю, ниже фрагмента можно использовать список всех файлов.

#include <stdio.h>
#include <dirent.h>
#include <sys/types.h>

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

Ниже приведена структура 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 */
};

Ответ 10

Попробуйте повысить для x-платформенного метода

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

или просто используйте файлы вашего конкретного файла.

Ответ 11

Проверьте этот класс, который использует win32 api. Просто создайте экземпляр, предоставив foldername, из которого вы хотите распечатать, затем вызовите метод getNextFile, чтобы получить следующий filename из каталога. Я думаю, что ему нужны windows.h и 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;
    }

};

Ответ 12

GNU Manual FTW

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

Кроме того, иногда хорошо идти прямо к источнику (каламбур). Вы можете многому научиться, глядя на внутренности некоторых из наиболее распространенных команд в Linux. Я создал простое зеркало GNU coreutils на github (для чтения).

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

Возможно, это не относится к Windows, но при использовании этих методов можно использовать несколько вариантов использования Unix-вариантов.

Надеюсь, что это поможет...

Ответ 13

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

Ответ 14

Я надеюсь, что этот код поможет вам.

#include <windows.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

string wchar_t2string(const wchar_t *wchar)
{
    string str = "";
    int index = 0;
    while(wchar[index] != 0)
    {
        str += (char)wchar[index];
        ++index;
    }
    return str;
}

wchar_t *string2wchar_t(const string &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<string> listFilesInDirectory(string directoryName)
{
    WIN32_FIND_DATA FindFileData;
    wchar_t * FileName = string2wchar_t(directoryName);
    HANDLE hFind = FindFirstFile(FileName, &FindFileData);

    vector<string> listFileNames;
    listFileNames.push_back(wchar_t2string(FindFileData.cFileName));

    while (FindNextFile(hFind, &FindFileData))
        listFileNames.push_back(wchar_t2string(FindFileData.cFileName));

    return listFileNames;
}

void main()
{
    vector<string> listFiles;
    listFiles = listFilesInDirectory("C:\\*.txt");
    for each (string str in listFiles)
        cout << str << endl;
}

Ответ 15

Ответ Shreevardhan отлично работает. Но если вы хотите использовать его в С++ 14, просто создайте namespace fs = experimental::filesystem; изменений namespace fs = experimental::filesystem;

т.е.

#include <string>
#include <iostream>
#include <filesystem>

using namespace std;
namespace fs = experimental::filesystem;

int main()
{
    string path = "C:\\splits\\";
    for (auto & p : fs::directory_iterator(path))
        cout << p << endl;
    int n;
    cin >> n;
}

Ответ 16

Эта реализация реализует вашу цель, динамически заполняя массив строк содержимым указанного каталога.

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

Ответ 17

Это работает для меня. Извините, если я не могу вспомнить источник. Вероятно, это с man-страницы.

#include <ftw.h>

int AnalizeDirectoryElement (const char *fpath, 
                            const struct stat *sb,
                            int tflag, 
                            struct FTW *ftwbuf) {

  if (tflag == FTW_F) {
    std::string 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/");
}

Ответ 18

вы можете получить все прямые файлы в корневом каталоге, используя std :: experimental :: filesystem :: directory_iterator(). Затем прочитайте имя этих файлов путей.

#include <iostream>
#include <filesystem>
#include <string>
#include <direct.h>
using namespace std;
namespace fs = std::experimental::filesystem;
void ShowListFile(string path)
{
for(auto &p: fs::directory_iterator(path))  /*get directory */
     cout<<p.path().filename()<<endl;   // get file name
}

int main() {

ShowListFile("C:/Users/dell/Pictures/Camera Roll/");
getchar();
return 0;
}

Ответ 19

Этот ответ должен работать для пользователей Windows, которым не удалось получить эту работу с Visual Studio с любыми другими ответами.

Загрузите файл dirent.h с страницы github. Но лучше просто использовать файл Raw dirent.h и следовать моим шагам ниже (это то, как я получил его на работу).

Страница Github для dirent.h для Windows: страница Github для dirent.h

Файл Raw Dirent: файл Raw dirent.h
Перейдите в свой проект и добавьте новый элемент (Ctrl + Shift + A). Добавьте файл заголовка (.h) и назовите его dirent.h.
Вставьте код Raw dirent.h в свой заголовок.
Включите "dirent.h" в свой код.

Поместите в свой код метод void filefinder() и вызовите его из main функции или отредактируйте функцию, как вы хотите ее использовать.

#include <stdio.h>
#include <string.h>
#include "dirent.h"

string 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 <stdio.h>
            //std::cout << direntStruct->d_name << std::endl; //If you are using <iostream>
        }
    }
    closedir(directory);
}

Ответ 20

Системный вызов!

system( "dir /b /s /a-d * > file_names.txt" );

Затем просто прочитайте файл.

EDIT: этот ответ следует считать взломом, но он действительно работает (хотя и определенно на платформе), если у вас нет доступа к более элегантным решениям.

Ответ 21

Поскольку файлы и вспомогательные каталоги каталога обычно хранятся в древовидной структуре, интуитивно понятным способом является использование алгоритма DFS для рекурсивного прохождения каждого из них. Вот пример в операционной системе Windows, используя основные функции файла в io.h. Вы можете заменить эти функции на другой платформе. Я хочу выразить, что основная идея DFS отлично справляется с этой проблемой.

#include<io.h>
#include<iostream.h>
#include<string>
using namespace std;

void TraverseFilesUsingDFS(const string& folder_path){
   _finddata_t file_info;
   string 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);
}

Ответ 22

Я попытался следовать примеру, указанному в обоих ответах, и, возможно, стоит отметить, что он выглядит так, как если бы std::filesystem::directory_entry была изменена, чтобы не иметь перегрузки оператора <<. Вместо std::cout << p << std::endl; Я должен был использовать следующее, чтобы иметь возможность компилировать и заставить его работать:

#include <iostream>
#include <filesystem>
#include <string>
namespace fs = std::filesystem;

int main() {
    std::string path = "/path/to/directory";
    for(const auto& p : fs::directory_iterator(path))
        std::cout << p.path() << std::endl;
}

пытаясь передать p самостоятельно, std::cout << привела к отсутствию ошибки перегрузки.

Ответ 23

Просто то, что я хочу поделиться, и поблагодарить вас за материал для чтения. Поиграйте с функцией, чтобы понять ее. Вам это может понравиться. e стоял за расширение, p для пути, а s - для разделителя пути.

Если путь передается без окончания разделителя, разделитель будет добавлен к пути. Для расширения, если вводится пустая строка, функция возвращает любой файл, который не имеет расширения в своем имени. Если была введена одна звезда, все файлы в каталоге будут возвращены. Если длина e больше 0, но не одна *, то точка будет добавлена к e, если e не содержала точку в нулевой позиции.

Для возвращаемого значения. Если возвращается карта нулевой длины, ничего не было найдено, но каталог был открыт нормально. Если индекс 999 доступен из возвращаемого значения, но размер карты равен только 1, это означает, что возникла проблема с открытием пути к каталогу.

Обратите внимание, что для эффективности эта функция может быть разделена на 3 функции меньшего размера. Кроме того, вы можете создать функцию вызывающего абонента, которая будет определять, какую функцию он будет вызывать на основе ввода. Почему это более эффективно? Говоря, что если вы собираетесь захватить все, что является файлом, делая этот метод, подфункция, созданная для захвата всех файлов, будет просто захватывать все файлы и не нужно оценивать какое-либо другое ненужное условие каждый раз, когда он находит файл.

Это также относится к тому, когда вы захватываете файлы, у которых нет расширения. Специальная встроенная функция для этой цели будет оценивать только погоду, если найденный объект является файлом, а затем, есть ли имя файла в нем.

Сохранение может быть не очень большим, если вы читаете только каталоги с не так большим количеством файлов. Но если вы читаете массовое количество каталогов, или если в каталоге есть несколько сотен тысяч файлов, это может быть огромной экономией.

#include <stdio.h>
#include <sys/stat.h>
#include <iostream>
#include <dirent.h>
#include <map>

std::map<int, std::string> getFile(std::string p, std::string e = "", unsigned char s = '/'){
    if ( p.size() > 0 ){
        if (p.back() != s) p += s;
    }
    if ( e.size() > 0 ){
        if ( e.at(0) != '.' && !(e.size() == 1 && e.at(0) == '*') ) e = "." + e;
    }

    DIR *dir;
    struct dirent *ent;
    struct stat sb;
    std::map<int, std::string> r = {{999, "FAILED"}};
    std::string temp;
    int f = 0;
    bool fd;

    if ( (dir = opendir(p.c_str())) != NULL ){
        r.erase (999);
        while ((ent = readdir (dir)) != NULL){
            temp = ent->d_name;
            fd = temp.find(".") != std::string::npos? true : false;
            temp = p + temp;

            if (stat(temp.c_str(), &sb) == 0 && S_ISREG(sb.st_mode)){
                if ( e.size() == 1 && e.at(0) == '*' ){
                    r[f] = temp;
                    f++;
                } else {
                    if (e.size() == 0){
                        if ( fd == false ){
                            r[f] = temp;
                            f++;
                        }
                        continue;
                    }

                    if (e.size() > temp.size()) continue;

                    if ( temp.substr(temp.size() - e.size()) == e ){
                        r[f] = temp;
                        f++;
                    }
                }
            }
        }

        closedir(dir);
        return r;
    } else {
        return r;
    }
}

void printMap(auto &m){
    for (const auto &p : m) {
        std::cout << "m[" << p.first << "] = " << p.second << std::endl;
    }
}

int main(){
    std::map<int, std::string> k = getFile("./", "");
    printMap(k);
    return 0;
}

Ответ 24

Основываясь на том, что herohuyongtao опубликовал и несколько других сообщений:

http://www.cplusplus.com/forum/general/39766/

Каков ожидаемый тип ввода FindFirstFile?

Как преобразовать wstring в строку?

Это решение для Windows.

Поскольку я хотел передать в std::string и вернуть вектор строк, мне пришлось сделать пару преобразований.

#include <string>
#include <Windows.h>
#include <vector>
#include <locale>
#include <codecvt>

std::vector<std::string> listFilesInDir(std::string path)
{
    std::vector<std::string> names;
    //Convert string to wstring
    std::wstring search_path = std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(path);
    WIN32_FIND_DATA fd;
    HANDLE hFind = FindFirstFile(search_path.c_str(), &fd);
    if (hFind != INVALID_HANDLE_VALUE) 
    {
        do 
        {
            // read all (real) files in current folder
            // , delete '!' read other 2 default folder . and ..
            if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) 
            {
                //convert from wide char to narrow char array
                char ch[260];
                char DefChar = ' ';
                WideCharToMultiByte(CP_ACP, 0, fd.cFileName, -1, ch, 260, &DefChar, NULL);
                names.push_back(ch);
            }
        } 
        while (::FindNextFile(hFind, &fd));
        ::FindClose(hFind);
    }
    return names;
}

Ответ 25

Это сработало для меня. Он записывает файл с именами (без пути) всех файлов. Затем он считывает этот txt файл и печатает его для вас.

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

    }