Styjun

Here's what I use:

/* Returns a list of files in a directory (except the ones that begin with a dot) */

void GetFilesInDirectory(std::vector<string> &out, const string &directory)

#ifdef WINDOWS
 HANDLE dir;
 WIN32_FIND_DATA file_data;

 if ((dir = FindFirstFile((directory + "/*").c_str(), &file_data)) == INVALID_HANDLE_VALUE)
 return; /* No files found */

 do 
 const string file_name = file_data.cFileName;
 const string full_file_name = directory + "/" + file_name;
 const bool is_directory = (file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;

 if (file_name[0] == '.')
 continue;

 if (is_directory)
 continue;

 out.push_back(full_file_name);
 while (FindNextFile(dir, &file_data));

 FindClose(dir);
#else
 DIR *dir;
 class dirent *ent;
 class stat st;

 dir = opendir(directory);
 while ((ent = readdir(dir)) != NULL) 
 const string file_name = ent->d_name;
 const string full_file_name = directory + "/" + file_name;

 if (file_name[0] == '.')
 continue;

 if (stat(full_file_name.c_str(), &st) == -1)
 continue;

 const bool is_directory = (st.st_mode & S_IFDIR) != 0;

 if (is_directory)
 continue;

 out.push_back(full_file_name);
 
 closedir(dir);
#endif
 // GetFilesInDirectory

Here's an example in C on Linux. That's if, you're on Linux and don't mind doing this small bit in ANSI C.

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

You have to use operating system calls (e.g. the Win32 API) or a wrapper around them. I tend to use Boost.Filesystem as it is superior interface compared to the mess that is the Win32 API (as well as being cross platform).

If you are looking to use the Win32 API, Microsoft has a list of functions and examples on msdn.

If you're in Windows & using MSVC, the MSDN library has sample code that does this.

And here's the code from that 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 %snn"), 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 bytesn"), 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) 

 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)) 
 closedir(dir);

Solving this will require a platform specific solution. Look for opendir() on unix/linux or FindFirstFile() on Windows. Or, there are many libraries that will handle the platform specific part for you.

I've just asked a similar question and here's my solution based on answer received (using boost::filesystem library):

#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 in a list
 
 cout << i->path().filename().string() << endl;
 
 else
 continue;
 

Output is like:

file1.txt
file2.dat

After combining a lot of snippets, I finally found a reuseable solution for Windows, that uses ATL Library, which comes with Visual Studio.

#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
 
 

To access the method, just call:

getFiles("i:\Folder1");

Or you do this and then read out the test.txt:

#include <windows.h>

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

The "/b" means just filenames are returned, no further info.

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

Setup the attributes to only look for directories.

You can use the following code for getting all files in a directory.A simple modification in the Andreas Bonini answer to remove the occurance of "." and ".."

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

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