file linux - Wie bekomme ich eine Liste von Dateien in einem Verzeichnis in C++?




for opendir (12)

void getFilesList(String filePath,String extension, vector<string> & returnFileName)
{
    WIN32_FIND_DATA fileInfo;
    HANDLE hFind;   
    String  fullPath = filePath + extension;
    hFind = FindFirstFile(fullPath.c_str(), &fileInfo);
    if (hFind == INVALID_HANDLE_VALUE){return;} 
    else {
        return FileName.push_back(filePath+fileInfo.cFileName);
        while (FindNextFile(hFind, &fileInfo) != 0){
            return FileName.push_back(filePath+fileInfo.cFileName);}
        }
 }


 String optfileName ="";        
 String inputFolderPath =""; 
 String extension = "*.jpg*";
 getFilesList(inputFolderPath,extension,filesPaths);
 vector<string>::const_iterator it = filesPaths.begin();
 while( it != filesPaths.end())
 {
    frame = imread(*it);//read file names
            //doyourwork here ( frame );
    sprintf(buf, "%s/Out/%d.jpg", optfileName.c_str(),it->c_str());
    imwrite(buf,frame);   
    it++;
 }

Wie erhalten Sie eine Liste von Dateien in einem Verzeichnis, so dass jedes verarbeitet werden kann?


HANDLE WINAPI FindFirstFile(
  __in   LPCTSTR lpFileName,
  __out  LPWIN32_FIND_DATA lpFindFileData
);

Richten Sie die Attribute so ein, dass nur nach Verzeichnissen gesucht wird.


Sie müssen Betriebssystemaufrufe (z. B. die Win32-API) oder einen Wrapper um sie herum verwenden. Ich neige dazu, Boost.Filesystem zu verwenden, da es eine Boost.Filesystem Schnittstelle ist als die Boost.Filesystem , die die Win32-API ist (und auch plattformübergreifend).

Wenn Sie die Win32-API verwenden möchten, verfügt Microsoft über eine Liste mit Funktionen und examples für msdn.


Wenn Sie sich in Windows befinden und MSVC verwenden, enthält die MSDN-Bibliothek Beispielcode.

Und hier ist der Code von diesem Link:

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

void ErrorHandler(LPTSTR lpszFunction);

int _tmain(int argc, TCHAR *argv[])
{
   WIN32_FIND_DATA ffd;
   LARGE_INTEGER filesize;
   TCHAR szDir[MAX_PATH];
   size_t length_of_arg;
   HANDLE hFind = INVALID_HANDLE_VALUE;
   DWORD dwError=0;

   // If the directory is not specified as a command-line argument,
   // print usage.

   if(argc != 2)
   {
      _tprintf(TEXT("\nUsage: %s <directory name>\n"), argv[0]);
      return (-1);
   }

   // Check that the input path plus 2 is not longer than MAX_PATH.

   StringCchLength(argv[1], MAX_PATH, &length_of_arg);

   if (length_of_arg > (MAX_PATH - 2))
   {
      _tprintf(TEXT("\nDirectory path is too long.\n"));
      return (-1);
   }

   _tprintf(TEXT("\nTarget directory is %s\n\n"), argv[1]);

   // Prepare string for use with FindFile functions.  First, copy the
   // string to a buffer, then append '\*' to the directory name.

   StringCchCopy(szDir, MAX_PATH, argv[1]);
   StringCchCat(szDir, MAX_PATH, TEXT("\\*"));

   // Find the first file in the directory.

   hFind = FindFirstFile(szDir, &ffd);

   if (INVALID_HANDLE_VALUE == hFind) 
   {
      ErrorHandler(TEXT("FindFirstFile"));
      return dwError;
   } 

   // List all the files in the directory with some info about them.

   do
   {
      if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
      {
         _tprintf(TEXT("  %s   <DIR>\n"), ffd.cFileName);
      }
      else
      {
         filesize.LowPart = ffd.nFileSizeLow;
         filesize.HighPart = ffd.nFileSizeHigh;
         _tprintf(TEXT("  %s   %ld bytes\n"), ffd.cFileName, filesize.QuadPart);
      }
   }
   while (FindNextFile(hFind, &ffd) != 0);

   dwError = GetLastError();
   if (dwError != ERROR_NO_MORE_FILES) 
   {
      ErrorHandler(TEXT("FindFirstFile"));
   }

   FindClose(hFind);
   return dwError;
}


void ErrorHandler(LPTSTR lpszFunction) 
{ 
    // Retrieve the system error message for the last-error code

    LPVOID lpMsgBuf;
    LPVOID lpDisplayBuf;
    DWORD dw = GetLastError(); 

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        dw,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR) &lpMsgBuf,
        0, NULL );

    // Display the error message and exit the process

    lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT, 
        (lstrlen((LPCTSTR)lpMsgBuf)+lstrlen((LPCTSTR)lpszFunction)+40)*sizeof(TCHAR)); 
    StringCchPrintf((LPTSTR)lpDisplayBuf, 
        LocalSize(lpDisplayBuf) / sizeof(TCHAR),
        TEXT("%s failed with error %d: %s"), 
        lpszFunction, dw, lpMsgBuf); 
    MessageBox(NULL, (LPCTSTR)lpDisplayBuf, TEXT("Error"), MB_OK); 

    LocalFree(lpMsgBuf);
    LocalFree(lpDisplayBuf);
}

C ++ 11 / Linux-Version:

#include <dirent.h>

if (auto dir = opendir("some_dir/")) {
    while (auto f = readdir(dir)) {
        if (!f->d_name || f->d_name[0] == '.')
            continue; // Skip everything that starts with a dot

        printf("File: %s\n", f->d_name);
    }
    closedir(dir);
}


Nachdem ich eine Menge Snippets kombiniert hatte, fand ich endlich eine wiederverwendbare Lösung für Windows, die ATL Library verwendet, die mit Visual Studio geliefert wird.

#include <atlstr.h>

void getFiles(CString directory) {
    HANDLE dir;
    WIN32_FIND_DATA file_data;
    CString  file_name, full_file_name;
    if ((dir = FindFirstFile((directory + "/*"), &file_data)) == INVALID_HANDLE_VALUE)
    {
        // Invalid directory
    }

    while (FindNextFile(dir, &file_data)) {
        file_name = file_data.cFileName;
        full_file_name = directory + file_name;
        if (strcmp(file_data.cFileName, ".") != 0 && strcmp(file_data.cFileName, "..") != 0)
        {
            std::string fileName = full_file_name.GetString();
            // Do stuff with fileName
        }
    }
}

Um auf die Methode zuzugreifen, rufen Sie einfach Folgendes an:

getFiles("i:\\Folder1");

Sie können den folgenden Code verwenden, um alle Dateien in einem Verzeichnis abzurufen. Eine einfache Änderung in der Andreas Bonini-Antwort, um das Auftreten von "." und ".."

CString dirpath="d:\\mydir"
DWORD errVal = ERROR_SUCCESS;
HANDLE dir;
WIN32_FIND_DATA file_data;
CString  file_name,full_file_name;
if ((dir = FindFirstFile((dirname+ "/*"), &file_data)) == INVALID_HANDLE_VALUE)
{
    errVal=ERROR_INVALID_ACCEL_HANDLE;
    return errVal;
}

while (FindNextFile(dir, &file_data)) {
    file_name = file_data.cFileName;
    full_file_name = dirname+ file_name;
    if (strcmp(file_data.cFileName, ".") != 0 && strcmp(file_data.cFileName, "..") != 0)
    {
        m_List.AddTail(full_file_name);
    }
}

Oder tu dies und lies dann die test.txt aus:

#include <windows.h>

int main() {    
system("dir /b > test.txt");
}

Das "/ b" bedeutet, dass nur Dateinamen zurückgegeben werden, keine weiteren Informationen.


Hier ist ein Beispiel in C unter Linux. Das ist, wenn Sie unter Linux sind und nichts dagegen haben, dieses kleine bisschen in ANSI C zu tun.

#include <dirent.h>

DIR *dpdf;
struct dirent *epdf;

dpdf = opendir("./");
if (dpdf != NULL){
   while (epdf = readdir(dpdf)){
      printf("Filename: %s",epdf->d_name);
      // std::cout << epdf->d_name << std::endl;
   }
}
closedir(dpdf);

Um dies zu lösen, wird eine plattformspezifische Lösung benötigt. Suchen Sie nach opendir () unter Unix / Linux oder FindFirstFile () unter Windows. Oder es gibt viele Bibliotheken, die den plattformspezifischen Teil für Sie übernehmen.


Ich habe das Problem auch mit leeren Verzeichnissen konfrontiert. Das Problem bei der Verwendung von Platzhalter-Dateien besteht darin, dass Sie sie erstellen und löschen müssen, wenn sie nicht mehr erforderlich sind (weil später Unterverzeichnisse oder Dateien hinzugefügt wurden. Bei der Verwaltung großer Platzbäume können diese Platzhalter-Dateien umständlich und fehlerhaft sein.) anfällig.

Aus diesem Grund habe ich mich entschlossen, ein Open Source-Tool zu schreiben, mit dem das Erstellen / Löschen solcher Platzhalter-Dateien automatisch verwaltet werden kann. Es ist für die .NET-Plattform geschrieben und läuft unter Mono (.NET für Linux) und Windows.

Schauen Sie einfach unter http://code.google.com/p/markemptydirs





c++ file directory