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

facile avec Boost.Système de fichiers: create_directories

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

retourne: true si un nouveau répertoire a été créé, sinon false .

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

est le chemin le plus court je pense (en termes de longueur de code, pas nécessairement le temps d'exécution).

ce n'est pas multiplate-forme 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);

à Partir de ici . Vous devrez peut-être faire des mkdirs distincts pour /tmp, /tmp/a, /tmp/a/b/ et then /tmp/A/b/C parce qu'il n'y a pas d'équivalent du drapeau-p dans l'api C. Soyez sûr et ignorez les EEXISTS errno pendant que vous faites les niveaux supérieurs.

Voici mon exemple de code (il 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;
}

Utilisation:

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

vous avez dit " C++ "mais tout le monde ici semble penser" Bash shell."

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

c'est similaire au précédent mais fonctionne en avant à travers la chaîne au lieu d'en arrière récursivement. Laisse errno avec la bonne valeur pour la dernière défaillance. S'il y a une barre oblique, 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 la barre oblique / et le paramètre pre à 1. L'efficacité est la même que l'on soit mis en place par une première boucle ou un appel pré-boucle, et la complexité serait (légèrement) plus élevée quand en utilisant l'appel pré-boucle.

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

int
mkpath(std::string s,mode_t mode)
{
    size_t pre=0,pos;
    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('/',pre))!=std::string::npos){
        dir=s.substr(0,pos++);
        pre=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';

}

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 de mkdirp() aujourd'hui, et a trouvé des solutions sur cette page, trop compliqué. Donc j'ai écrit un assez court extrait, qui facilement être copié pour les autres qui trébuchez sur ce fil une merveille 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 != '"151910920"') {
    // Skip first character
    p++;

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

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

    // Write end of string at p
    *p = '"151910920"';

    // Create folder from path to '"151910920"' 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 montage et la modification temporaire string, fais juste un strdup() et free() après.

étant donné que ce message est classé haut dans Google pour" créer L'arborescence des répertoires", je vais poster une réponse qui fonctionnera pour Windows - cela fonctionnera en utilisant L'API Win32 compilé pour UNICODE ou MBCS. C'est porté à partir du code de Mark ci-dessus.

Puisqu'il s'agit de Windows avec lequel nous travaillons, les séparateurs de répertoires sont des barres obliques, pas des barres obliques. Si vous préférez les barres obliques, changez '\' en '/'

il fonctionnera avec:

c:\foo\bar\hello\world

et

c:\foo\bar\hellp\world\

(i.e.: n'a pas besoin de slash arrière, de sorte que vous n'avez pas à vérifier pour elle.)

avant de dire "il suffit d'utiliser SHCreateDirectoryEx () dans Windows", notez que SHCreateDirectoryEx () est déprécié et peut être supprimé à tout moment des versions futures 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 haut sur les résultats de recherche de 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 levage lourd (vérification des erreurs, validation du chemin) doit être fait par createDir() de toute façon. De plus, createDir() devrait retourner true si directory existe déjà ou si tout ne fonctionne pas.

Voici comment je ferait 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à assez d'exemples dans d'autres réponses comment l'écrire pour linux, donc j'ai décidé de la Sauter.

si dir n'existe pas, créer:

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

mkdir -p /dir/to/the/file

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

les autres t'ont donné la bonne réponse, mais j'ai pensé te montrer une autre chose que tu peux faire:

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

va créer les chemins suivants:

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

les accolades vous permettent de créer plusieurs répertoires à la fois sur le même niveau de la hiérarchie, tandis que l'option -p signifie"créer des répertoires parents selon les besoins".