analyse récursive des dossiers en c ++

Voir ftw homme pour une simple "de l'arborescence de fichiers à pied". J'ai aussi utilisé fnmatch dans cet exemple.

#include <ftw.h>
#include <fnmatch.h>

static const char *filters[] = {
    "*.jpg", "*.jpeg", "*.gif", "*.png"
};

static int callback(const char *fpath, const struct stat *sb, int typeflag) {
    /* if it's a file */
    if (typeflag == FTW_F) {
        int i;
        /* for each filter, */
        for (i = 0; i < sizeof(filters) / sizeof(filters[0]); i++) {
            /* if the filename matches the filter, */
            if (fnmatch(filters[i], fpath, FNM_CASEFOLD) == 0) {
                /* do something */
                printf("found image: %s\n", fpath);
                break;
            }
        }
    }

    /* tell ftw to continue */
    return 0;
}

int main() {
    ftw(".", callback, 16);
}

(Même pas de compilation à l'essai, mais vous obtenez l'idée.)

C'est beaucoup plus simple que de traiter avec DIRENTs et récursive de la traversée à vous-même.

---

Pour un plus grand contrôle de la traversée, il y a aussi m. Dans cet exemple, le point-files (fichiers et répertoires avec des noms commençant par ".") sont ignorés, sauf s'il est explicitement transmis au programme en tant que point de départ.

#include <fts.h>
#include <string.h>

int main(int argc, char **argv) {
    char *dot[] = {".", 0};
    char **paths = argc > 1 ? argv + 1 : dot;

    FTS *tree = fts_open(paths, FTS_NOCHDIR, 0);
    if (!tree) {
        perror("fts_open");
        return 1;
    }

    FTSENT *node;
    while ((node = fts_read(tree))) {
        if (node->fts_level > 0 && node->fts_name[0] == '.')
            fts_set(tree, node, FTS_SKIP);
        else if (node->fts_info & FTS_F) {
            printf("got file named %s at depth %d, "
                "accessible via %s from the current directory "
                "or via %s from the original starting directory\n",
                node->fts_name, node->fts_level,
                node->fts_accpath, node->fts_path);
            /* if fts_open is not given FTS_NOCHDIR,
             * fts may change the program's current working directory */
        }
    }
    if (errno) {
        perror("fts_read");
        return 1;
    }

    if (fts_close(tree)) {
        perror("fts_close");
        return 1;
    }

    return 0;
}

Encore une fois, ce n'est ni de la compilation testé ni l'exécution testé, mais j'ai pensé que je le mentionne.

Je suis de la vieille école, pas de ftw() pour moi! C'est brut (ça fait un moment depuis que je l'ai fait directement la programmation en C), et beaucoup de choses est codé en dur, et j'ai probablement foiré mes calculs de longueur pour le strnc*() fonctionne, mais vous obtenez l'idée. Il y a un exemple similaire dans le K&R btw.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
void listdir(char* dirname, int lvl);
int main(int argc, char** argv)
{
if (argc != 2) {
fprintf(stderr, "Incorrect usage!\n");
exit(-1);
}
listdir(argv[1], 0);
return 0;
}
void listdir(char* dirname, int lvl)
{
int i;
DIR* d_fh;
struct dirent* entry;
char longest_name[4096];
while( (d_fh = opendir(dirname)) == NULL) {
fprintf(stderr, "Couldn't open directory: %s\n", dirname);
exit(-1);
}
while((entry=readdir(d_fh)) != NULL) {
/* Don't descend up the tree or include the current directory */
if(strncmp(entry->d_name, "..", 2) != 0 &&
strncmp(entry->d_name, ".", 1) != 0) {
/* If it's a directory print it's name and recurse into it */
if (entry->d_type == DT_DIR) {
for(i=0; i < 2*lvl; i++) {
printf(" ");
}
printf("%s (d)\n", entry->d_name);
/* Prepend the current directory and recurse */
strncpy(longest_name, dirname, 4095);
strncat(longest_name, "/", 4095);
strncat(longest_name, entry->d_name, 4095);
listdir(longest_name, lvl+1);
}
else {
/* Print some leading space depending on the directory level */
for(i=0; i < 2*lvl; i++) {
printf(" ");
}
printf("%s\n", entry->d_name);
}
}
}
closedir(d_fh);
return;
}

Vous pouvez également utiliser glob/globfree.