Error reading many files in a subfolder - c++

Question

I have a problem with read file in the subfolder. I have about 6000 different files in the difference folders. And I will read each file. But if I read about 2000 files, then application is not problem. When I read 6000 files which mean whole subfolders. The application will display problem "can not open file.". But if I only access the folder that is not open, then application is not problem. I don't know what is happen? I think maybe I read many files and memory not enough. Can you edit help me?
//This is code to access subforder
static int
find_directory(
const char *dirname)
{
DIR *dir;
char buffer[PATH_MAX + 2];
char *p = buffer;
const char *src;
const char* folder_dir;
char *end = &buffer[PATH_MAX];
int ok;
/* Copy directory name to buffer */
src = dirname;
printf("src=%s\n",src);
while (p < end && *src != '\0') {
*p++ = *src++;
}
*p = '\0';
/* Open directory stream */
dir = opendir (dirname);
if (dir != NULL) {
struct dirent *ent;
/* Print all files and directories within the directory */
while ((ent = readdir (dir)) != NULL) {
char *q = p;
char c;
/* Get final character of directory name */
if (buffer < q) {
c = q[-1];
} else {
c = ':';
}
/* Append directory separator if not already there */
if (c != ':' && c != '/' && c != '\\') {
*q++ = '/';
}
/* Append file name */
src = ent->d_name;
while (q < end && *src != '\0') {
*q++ = *src++;
}
*q = '\0';
/* Decide what to do with the directory entry */
switch (ent->d_type) {
case DT_REG:
/* Output file name with directory */
{
printf ("FILE=%s\n", buffer);
OFBool check= readfile(buffer)
}
break;
case DT_DIR:
/* Scan sub-directory recursively */
if (strcmp (ent->d_name, ".") != 0
&& strcmp (ent->d_name, "..") != 0) {
find_directory (buffer,opts);
}
break;
default:
/* Do not device entries */
/*NOP*/;
}
}
closedir (dir);
ok = 1;
} else {
/* Could not open directory */
printf ("Cannot open directory %s\n", dirname);
ok = 0;
}
return ok;
}
OFBool readfile(const char* filepath)
{
FILE *f=NULL;
OFBool ok = OFFalse;
if( ( f = fopen( filepath, "rb" ) ) == NULL ) // checks to see if file exists
{
ok = OFFalse;
cout<<"can not read file"<<filepath<<endl;
return ok;
}
else
{
ok = true;
cout<<" reading OK"<<endl;
fclose(f);
return ok;
}
}

Answer 1

How about something like this:
/*
* Recursively walk though a directory tree.
*
* Arguments:
* path - The root directory to start from
* hidden - If non-zero, include hidden files and directories
*/
void recurse_directory(const char *path, const int hidden)
{
DIR *dir = opendir(path);
if (dir == NULL)
{
perror("opendir");
return;
}
struct dirent *ent;
while ((ent = readdir(dir)) != NULL)
{
if (ent->d_type == DT_DIR)
{
if (strcmp(ent->d_name, ".") != 0 &&
strcmp(ent->d_name, "..") != 0 &&
(ent->d_name[0] != '.' || hidden))
{
char *newpath = malloc(strlen(path) + 1 + strlen(ent->d_name) + 1);
strcpy(newpath, path);
strcat(newpath, "/");
strcat(newpath, ent->d_name);
recurse_directory(newpath, hidden);
free(newpath);
}
}
else if (ent->d_type == DT_REG)
{
if (ent->d_name[0] != '.' || hidden)
{
char *newpath = malloc(strlen(path) + 1 + strlen(ent->d_name) + 1);
strcpy(newpath, path);
strcat(newpath, "/");
strcat(newpath, ent->d_name);
printf("File %s\n", newpath);
/* readfile(newpath); */
free(newpath);
}
}
}
}

Answer 2

Too add to the answer from Joachim Pileborg. If you are working with a large number of sub-directories you'd need to add closedir() call after while loop. This is because there is a limit on the number of directories you can have open at one time. The above example will work fine when working with a small folder, but when working with 2000+ sub-folders you'd need to close the directory before opening another.
/*
* Recursively walk though a directory tree.
*
* Arguments:
* path - The root directory to start from
* hidden - If non-zero, include hidden files and directories
*/
void recurse_directory(const char *path, const int hidden)
{
DIR *dir = opendir(path);
if (dir == NULL)
{
perror("opendir");
return;
}
struct dirent *ent;
while ((ent = readdir(dir)) != NULL)
{
if (ent->d_type == DT_DIR)
{
if (strcmp(ent->d_name, ".") != 0 &&
strcmp(ent->d_name, "..") != 0 &&
(ent->d_name[0] != '.' || hidden))
{
char *newpath = malloc(strlen(path) + 1 + strlen(ent->d_name) + 1);
strcpy(newpath, path);
strcat(newpath, "/");
strcat(newpath, ent->d_name);
recurse_directory(newpath, hidden);
free(newpath);
}
}
else if (ent->d_type == DT_REG)
{
if (ent->d_name[0] != '.' || hidden)
{
char *newpath = malloc(strlen(path) + 1 + strlen(ent->d_name) + 1);
strcpy(newpath, path);
strcat(newpath, "/");
strcat(newpath, ent->d_name);
printf("File %s\n", newpath);
/* readfile(newpath); */
free(newpath);
}
}
}
closedir(dir); /* Add this <--- */
}