Comment puis-je créer une arborescence de répertoires en C ++ / Linux?

Je veux un moyen simple de créer plusieurs répertoires en C ++ / Linux.

Par exemple, je souhaite enregistrer un fichier lola.file dans le répertoire:

/tmp/a/b/c

mais si les répertoires ne sont pas là, je veux qu'ils soient créés automatiquement. Un exemple de travail serait parfait.

Avec C ++ 17 ou version ultérieure, il y a l'en-tête standard <filesystem>avec une fonction std::filesystem::create_directories qui devrait être utilisée dans les programmes C ++ modernes. Les fonctions standard C ++ n'ont cependant pas l'argument d'autorisations explicites (mode) spécifique à POSIX.

Cependant, voici une fonction C qui peut être compilée avec des compilateurs C ++.

/*
@(#)File:           mkpath.c
@(#)Purpose:        Create all directories in path
@(#)Author:         J Leffler
@(#)Copyright:      (C) JLSS 1990-2020
@(#)Derivation:     mkpath.c 1.16 2020/06/19 15:08:10
*/

/*TABSTOP=4*/

#include "posixver.h"
#include "mkpath.h"
#include "emalloc.h"

#include <errno.h>
#include <string.h>
/* "sysstat.h" == <sys/stat.h> with fixup for (old) Windows - inc mode_t */
#include "sysstat.h"

typedef struct stat Stat;

static int do_mkdir(const char *path, mode_t mode)
{
    Stat            st;
    int             status = 0;

    if (stat(path, &st) != 0)
    {
        /* Directory does not exist. EEXIST for race condition */
        if (mkdir(path, mode) != 0 && errno != EEXIST)
            status = -1;
    }
    else if (!S_ISDIR(st.st_mode))
    {
        errno = ENOTDIR;
        status = -1;
    }

    return(status);
}

/**
** mkpath - ensure all directories in path exist
** Algorithm takes the pessimistic view and works top-down to ensure
** each directory in path exists, rather than optimistically creating
** the last element and working backwards.
*/
int mkpath(const char *path, mode_t mode)
{
    char           *pp;
    char           *sp;
    int             status;
    char           *copypath = STRDUP(path);

    status = 0;
    pp = copypath;
    while (status == 0 && (sp = strchr(pp, '/')) != 0)
    {
        if (sp != pp)
        {
            /* Neither root nor double slash in path */
            *sp = '\0';
            status = do_mkdir(copypath, mode);
            *sp = '/';
        }
        pp = sp + 1;
    }
    if (status == 0)
        status = do_mkdir(path, mode);
    FREE(copypath);
    return (status);
}

#ifdef TEST

#include <stdio.h>
#include <unistd.h>

/*
** Stress test with parallel running of mkpath() function.
** Before the EEXIST test, code would fail.
** With the EEXIST test, code does not fail.
**
** Test shell script
** PREFIX=mkpath.$$
** NAME=./$PREFIX/sa/32/ad/13/23/13/12/13/sd/ds/ww/qq/ss/dd/zz/xx/dd/rr/ff/ff/ss/ss/ss/ss/ss/ss/ss/ss
** : ${MKPATH:=mkpath}
** ./$MKPATH $NAME &
** [...repeat a dozen times or so...]
** ./$MKPATH $NAME &
** wait
** rm -fr ./$PREFIX/
*/

int main(int argc, char **argv)
{
    int             i;

    for (i = 1; i < argc; i++)
    {
        for (int j = 0; j < 20; j++)
        {
            if (fork() == 0)
            {
                int rc = mkpath(argv[i], 0777);
                if (rc != 0)
                    fprintf(stderr, "%d: failed to create (%d: %s): %s\n",
                            (int)getpid(), errno, strerror(errno), argv[i]);
                exit(rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
            }
        }
        int status;
        int fail = 0;
        while (wait(&status) != -1)
        {
            if (WEXITSTATUS(status) != 0)
                fail = 1;
        }
        if (fail == 0)
            printf("created: %s\n", argv[i]);
    }
    return(0);
}

#endif /* TEST */

Les macros STRDUP()et FREE()sont des versions de vérification des erreurs de strdup()et free(), déclarées dans emalloc.h(et implémentées dans emalloc.cet estrdup.c). L'en- "sysstat.h"tête traite des versions cassées de <sys/stat.h> et peut être remplacé par <sys/stat.h>sur les systèmes Unix modernes (mais il y avait de nombreux problèmes en 1990). Et "mkpath.h"déclare mkpath().

Le changement entre v1.12 (version originale de la réponse) et v1.13 (version modifiée de la réponse) était le test pour EEXISTdans do_mkdir(). Cela a été signalé comme nécessaire par Switch - merci, Switch. Le code de test a été mis à jour et reproduit le problème sur un MacBook Pro (Intel Core i7 2,3 GHz, exécutant Mac OS X 10.7.4), et suggère que le problème est résolu dans la révision (mais les tests ne peuvent montrer que la présence de bogues , jamais leur absence). Le code affiché est maintenant v1.16; des modifications cosmétiques ou administratives ont été apportées depuis la v1.13 (comme l'utilisation à la mkpath.hplace de jlss.het l'inclusion <unistd.h>inconditionnelle dans le code de test uniquement). Il est raisonnable de dire que cela "sysstat.h"devrait être remplacé par à <sys/stat.h>moins que vous n'ayez un système inhabituellement récalcitrant.

(Vous êtes autorisé par la présente à utiliser ce code à toute fin avec attribution.)

Ce code est disponible dans mon référentiel SOQ (Stack Overflow Questions) sur GitHub sous forme de fichiers mkpath.cet mkpath.h(etc.) dans le sous-répertoire src / so-0067-5039 .

Facile avec Boost.Filesystem: create_directories

#include <boost/filesystem.hpp>
//...
boost::filesystem::create_directories("/tmp/a/b/c");

Retourne: truesi un nouveau répertoire a été créé, sinon false.

system("mkdir -p /tmp/a/b/c")

est le moyen le plus court auquel je puisse penser (en termes de longueur de code, pas nécessairement de temps d'exécution).

Ce n'est pas multiplateforme mais fonctionnera sous Linux.

#include <sys/types.h>
#include <sys/stat.h>

int status;
...
status = mkdir("/tmp/a/b/c", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);

D' ici . Vous devrez peut-être faire des mkdirs séparés pour / tmp, / tmp / a, / tmp / a / b / et ensuite / tmp / a / b / c car il n'y a pas d'équivalent de l'indicateur -p dans l'API C. Soyez sûr et ignorez l'erreur EEXISTS pendant que vous faites les niveaux supérieurs.

Voici mon exemple de code (cela fonctionne à la fois pour Windows et Linux):

#include <iostream>
#include <string>
#include <sys/stat.h> // stat
#include <errno.h>    // errno, ENOENT, EEXIST
#if defined(_WIN32)
#include <direct.h>   // _mkdir
#endif

bool isDirExist(const std::string& path)
{
#if defined(_WIN32)
    struct _stat info;
    if (_stat(path.c_str(), &info) != 0)
    {
        return false;
    }
    return (info.st_mode & _S_IFDIR) != 0;
#else 
    struct stat info;
    if (stat(path.c_str(), &info) != 0)
    {
        return false;
    }
    return (info.st_mode & S_IFDIR) != 0;
#endif
}

bool makePath(const std::string& path)
{
#if defined(_WIN32)
    int ret = _mkdir(path.c_str());
#else
    mode_t mode = 0755;
    int ret = mkdir(path.c_str(), mode);
#endif
    if (ret == 0)
        return true;

    switch (errno)
    {
    case ENOENT:
        // parent didn't exist, try to create it
        {
            int pos = path.find_last_of('/');
            if (pos == std::string::npos)
#if defined(_WIN32)
                pos = path.find_last_of('\\');
            if (pos == std::string::npos)
#endif
                return false;
            if (!makePath( path.substr(0, pos) ))
                return false;
        }
        // now, try to create again
#if defined(_WIN32)
        return 0 == _mkdir(path.c_str());
#else 
        return 0 == mkdir(path.c_str(), mode);
#endif

    case EEXIST:
        // done!
        return isDirExist(path);

    default:
        return false;
    }
}

int main(int argc, char* ARGV[])
{
    for (int i=1; i<argc; i++)
    {
        std::cout << "creating " << ARGV[i] << " ... " << (makePath(ARGV[i]) ? "OK" : "failed") << std::endl;
    }
    return 0;
}

Usage:

$ makePath 1/2 folderA/folderB/folderC
creating 1/2 ... OK
creating folderA/folderB/folderC ... OK

Il est à noter qu'à partir de l'interface du système de fichiers C ++ 17 fait partie de la bibliothèque standard. Cela signifie que l'on peut avoir les éléments suivants pour créer des répertoires:

#include <filesystem>

std::filesystem::create_directories("/a/b/c/d")

Plus d'informations ici: https://en.cppreference.com/w/cpp/filesystem/create_directory

De plus, avec gcc, il faut "-std = c ++ 17" vers CFLAGS. Et "-lstdc ++ fs" vers LDLIBS. Ce dernier ne sera potentiellement pas nécessaire à l'avenir.

Ceci est similaire au précédent mais fonctionne en avant à travers la chaîne au lieu de recursivement en arrière. Laisse errno avec la bonne valeur pour le dernier échec. S'il y a une barre oblique au début, il y a un temps supplémentaire dans la boucle qui aurait pu être évité via un find_first_of () en dehors de la boucle ou en détectant le premier / et en mettant pre à 1. L'efficacité est la même que nous soyons configurés par un première boucle ou un appel de pré-boucle, et la complexité serait (légèrement) plus élevée lors de l'utilisation de l'appel de pré-boucle.

#include <iostream>
#include <string>
#include <sys/stat.h>

int
mkpath(std::string s,mode_t mode)
{
    size_t pos=0;
    std::string dir;
    int mdret;

    if(s[s.size()-1]!='/'){
        // force trailing / so we can handle everything in loop
        s+='/';
    }

    while((pos=s.find_first_of('/',pos))!=std::string::npos){
        dir=s.substr(0,pos++);
        if(dir.size()==0) continue; // if leading / first time is 0 length
        if((mdret=mkdir(dir.c_str(),mode)) && errno!=EEXIST){
            return mdret;
        }
    }
    return mdret;
}

int main()
{
    int mkdirretval;
    mkdirretval=mkpath("./foo/bar",0755);
    std::cout << mkdirretval << '\n';

}

Vous avez dit «C ++», mais tout le monde ici semble penser «shell Bash».

Consultez le code source de gnu mkdir; alors vous pouvez voir comment implémenter les commandes shell en C ++.

bool mkpath( std::string path )
{
    bool bSuccess = false;
    int nRC = ::mkdir( path.c_str(), 0775 );
    if( nRC == -1 )
    {
        switch( errno )
        {
            case ENOENT:
                //parent didn't exist, try to create it
                if( mkpath( path.substr(0, path.find_last_of('/')) ) )
                    //Now, try to create again.
                    bSuccess = 0 == ::mkdir( path.c_str(), 0775 );
                else
                    bSuccess = false;
                break;
            case EEXIST:
                //Done!
                bSuccess = true;
                break;
            default:
                bSuccess = false;
                break;
        }
    }
    else
        bSuccess = true;
    return bSuccess;
}

J'ai donc besoin mkdirp()aujourd'hui, et trouve les solutions sur cette page trop compliquées. Par conséquent, j'ai écrit un extrait assez court, qui peut facilement être copié pour ceux qui tombent sur ce fil de discussion et se demandent pourquoi nous avons besoin de tant de lignes de code.

mkdirp.h

#ifndef MKDIRP_H
#define MKDIRP_H

#include <sys/stat.h>

#define DEFAULT_MODE      S_IRWXU | S_IRGRP |  S_IXGRP | S_IROTH | S_IXOTH

/** Utility function to create directory tree */
bool mkdirp(const char* path, mode_t mode = DEFAULT_MODE);

#endif // MKDIRP_H

mkdirp.cpp

#include <errno.h>

bool mkdirp(const char* path, mode_t mode) {
  // const cast for hack
  char* p = const_cast<char*>(path);

  // Do mkdir for each slash until end of string or error
  while (*p != '\0') {
    // Skip first character
    p++;

    // Find first slash or end
    while(*p != '\0' && *p != '/') p++;

    // Remember value from p
    char v = *p;

    // Write end of string at p
    *p = '\0';

    // Create folder from path to '\0' inserted at p
    if(mkdir(path, mode) == -1 && errno != EEXIST) {
      *p = v;
      return false;
    }

    // Restore path to it's former glory
    *p = v;
  }

  return true;
}

Si vous n'aimez pas le cast const et la modification temporaire de la chaîne, faites simplement un strdup()et free()après.

Étant donné que cet article est bien classé dans Google pour "Créer une arborescence de répertoires", je vais publier une réponse qui fonctionnera pour Windows - cela fonctionnera en utilisant l'API Win32 compilée pour UNICODE ou MBCS. Ceci est porté à partir du code de Mark ci-dessus.

Puisqu'il s'agit de Windows avec lequel nous travaillons, les séparateurs de répertoire sont des barres obliques ARRIÈRE, pas des barres obliques. Si vous préférez avoir des barres obliques, passez '\\'à'/'

Cela fonctionnera avec:

c:\foo\bar\hello\world

et

c:\foo\bar\hellp\world\

(c'est-à-dire: n'a pas besoin de barre oblique de fin, vous n'avez donc pas à le vérifier.)

Avant de dire «Utilisez simplement SHCreateDirectoryEx () sous Windows», notez que SHCreateDirectoryEx () est obsolète et pourrait être supprimé à tout moment des futures versions de Windows.

bool CreateDirectoryTree(LPCTSTR szPathTree, LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL){
    bool bSuccess = false;
    const BOOL bCD = CreateDirectory(szPathTree, lpSecurityAttributes);
    DWORD dwLastError = 0;
    if(!bCD){
        dwLastError = GetLastError();
    }else{
        return true;
    }
    switch(dwLastError){
        case ERROR_ALREADY_EXISTS:
            bSuccess = true;
            break;
        case ERROR_PATH_NOT_FOUND:
            {
                TCHAR szPrev[MAX_PATH] = {0};
                LPCTSTR szLast = _tcsrchr(szPathTree,'\\');
                _tcsnccpy(szPrev,szPathTree,(int)(szLast-szPathTree));
                if(CreateDirectoryTree(szPrev,lpSecurityAttributes)){
                    bSuccess = CreateDirectory(szPathTree,lpSecurityAttributes)!=0;
                    if(!bSuccess){
                        bSuccess = (GetLastError()==ERROR_ALREADY_EXISTS);
                    }
                }else{
                    bSuccess = false;
                }
            }
            break;
        default:
            bSuccess = false;
            break;
    }

    return bSuccess;
}

Je sais que c'est une vieille question, mais elle apparaît en bonne place dans les résultats de recherche Google et les réponses fournies ici ne sont pas vraiment en C ++ ou sont un peu trop compliquées.

Veuillez noter que dans mon exemple, createDirTree () est très simple car tout le travail lourd (vérification des erreurs, validation de chemin) doit être fait de toute façon par createDir (). De plus, createDir () devrait retourner true si le répertoire existe déjà ou si tout ne fonctionnera pas.

Voici comment je ferais cela en C ++:

#include <iostream>
#include <string>

bool createDir(const std::string dir)
{
    std::cout << "Make sure dir is a valid path, it does not exist and create it: "
              << dir << std::endl;
    return true;
}

bool createDirTree(const std::string full_path)
{
    size_t pos = 0;
    bool ret_val = true;

    while(ret_val == true && pos != std::string::npos)
    {
        pos = full_path.find('/', pos + 1);
        ret_val = createDir(full_path.substr(0, pos));
    }

    return ret_val;
}

int main()
{
    createDirTree("/tmp/a/b/c");
    return 0;
}

Bien sûr, la fonction createDir () sera spécifique au système et il y a déjà suffisamment d'exemples dans d'autres réponses pour l'écrire pour Linux, j'ai donc décidé de l'ignorer.

Si dir n'existe pas, créez-le:

boost::filesystem::create_directories(boost::filesystem::path(output_file).parent_path().string().c_str()); 

De nombreuses approches ont été décrites ici, mais la plupart d'entre elles nécessitent un codage en dur de votre chemin dans votre code. Il existe une solution simple à ce problème, en utilisant QDir et QFileInfo, deux classes du framework Qt. Étant donné que vous êtes déjà dans un environnement Linux, il devrait être facile d'utiliser Qt.

QString qStringFileName("path/to/the/file/that/dont/exist.txt");
QDir dir = QFileInfo(qStringFileName).dir();
if(!dir.exists()) {
        dir.mkpath(dir.path());
}

Assurez-vous que vous disposez d'un accès en écriture à ce chemin.

mkdir -p /dir/to/the/file

touch /dir/to/the/file/thefile.ending

Voici la fonction récursive C / C ++ qui utilise dirname()pour parcourir de bas en haut l'arborescence de répertoires. Il s'arrêtera dès qu'il trouvera un ancêtre existant.

#include <libgen.h>
#include <string.h>

int create_dir_tree_recursive(const char *path, const mode_t mode)
{
    if (strcmp(path, "/") == 0) // No need of checking if we are at root.
        return 0;

    // Check whether this dir exists or not.
    struct stat st;
    if (stat(path, &st) != 0 || !S_ISDIR(st.st_mode))
    {
        // Check and create parent dir tree first.
        char *path2 = strdup(path);
        char *parent_dir_path = dirname(path2);
        if (create_dir_tree_recursive(parent_dir_path, mode) == -1)
            return -1;

        // Create this dir.
        if (mkdir(path, mode) == -1)
            return -1;
    }

    return 0;
}

Les autres vous ont donné la bonne réponse, mais j'ai pensé vous montrer une autre chose intéressante que vous pouvez faire:

mkdir -p /tmp/a/{b,c}/d

Créera les chemins suivants:

/tmp/a/b/d
/tmp/a/c/d

Les accolades vous permettent de créer plusieurs répertoires à la fois au même niveau de la hiérarchie, alors que l' -poption signifie «créer des répertoires parents selon les besoins».