Comment puis-je créer un répertoire de l'arborescence en C++/Linux?

Voici une fonction C qui peut être compilé avec les compilateurs C++.

/*
@(#)File:           $RCSfile: mkpath.c,v $
@(#)Version:        $Revision: 1.13 $
@(#)Last changed:   $Date: 2012/07/15 00:40:37 $
@(#)Purpose:        Create all directories in path
@(#)Author:         J Leffler
@(#)Copyright:      (C) JLSS 1990-91,1997-98,2001,2005,2008,2012
*/
/*TABSTOP=4*/
#include "jlss.h"
#include "emalloc.h"
#include <errno.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif /* HAVE_UNISTD_H */
#include <string.h>
#include "sysstat.h"    /* Fix up for Windows - inc mode_t */
typedef struct stat Stat;
#ifndef lint
/* Prevent over-aggressive optimizers from eliminating ID string */
const char jlss_id_mkpath_c[] = "@(#)$Id: mkpath.c,v 1.13 2012/07/15 00:40:37 jleffler Exp $";
#endif /* lint */
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>
/*
** 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 d'erreur de vérification des versions de strdup() et free(), a déclaré dans emalloc.h (et mis en œuvre dans emalloc.c et estrdup.c). Le "sysstat.h" en-tête de traite cassé versions de <sys/stat.h> et peut être remplacé par <sys/stat.h> sur les systèmes Unix modernes (mais il y avait beaucoup de questions en 1990). Et "jlss.h" déclare mkpath().

Le changement entre les v1.12 (précédent) et v1.13 (ci-dessus) est le test de la EEXIST dans do_mkdir(). Cela a été souligné que de besoin, par Commutateur — merci à vous, passez. Le code de test a été mis à niveau et de reproduire le problème sur un MacBook Pro (2,3 GHz Intel Core i7, fonctionnant sous Mac OS X 10.7.4), et suggère que le problème est corrigé dans la révision (mais les tests ne peuvent montrer la présence de bugs, de ne jamais leur absence).

(Vous êtes par les présentes donné la permission d'utiliser ce code pour n'importe quel but avec mention de la source.)

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

Il n'est pas multi-plateforme, 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);

De ici. Vous pourriez avoir à faire des mkdirs pour /tmp, /tmp,/a, /tmp/a/b/et puis /tmp/a/b/c parce que il n'y a pas un équivalent de l'option-p au C de l'api. Assurez-vous et d'ignorer les EEXISTS errno pendant que vous êtes en train de faire du haut niveau.

Il convient de noter qu'à partir de C++17 système de fichiers de l'interface est la partie de la bibliothèque standard. Cela signifie que l'on peut avoir à la suite de la création de répertoires:

#include <filesystem>
std::filesystem::create_directories("/a/b/c/d")

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

En outre, avec gcc, il faut "-std=c++17" à CFLAGS. Et "-lstdc++fs" pour LDLIBS. Le dernier potentiellement ne va pas être nécessaire dans le futur.

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 d' 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
tomber sur ce fil un demander pourquoi nous avons besoin d'autant 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 const casting et en modifiant temporairement la chaîne, il suffit de faire une strdup() et free() par la suite.

Si dir n'existe pas, la créer:

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

Les autres vous avez le droit de réponse, mais j'ai pensé que je voudrais vous montrer une autre chose que vous pouvez faire:

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

Permettra de créer des chemins d'accès suivants:

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

Les accolades permettent de créer plusieurs répertoires à la fois sur le même niveau de la hiérarchie, alors que la -p option "créer les répertoires parents en tant que de besoin".