system("mkdir -p /tmp/a/b/c")
è il modo più breve a cui riesco a pensare (in termini di lunghezza del codice, non necessariamente tempo di esecuzione).
Non è multipiattaforma ma funzionerà sotto Linux.
Facile con Boost.Filesystem:create_directories
#include <boost/filesystem.hpp>
//...
boost::filesystem::create_directories("/tmp/a/b/c");
Restituisce:true se è stata creata una nuova directory, altrimenti false .
Ecco il mio esempio di codice (funziona sia per Windows che per 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;
}
Utilizzo:
$ makePath 1/2 folderA/folderB/folderC
creating 1/2 ... OK
creating folderA/folderB/folderC ... OK
Con C++17 o successivo, c'è l'intestazione standard <filesystem> con funzionestd::filesystem::create_directories che dovrebbe essere usato nei moderni programmi C++. Le funzioni standard C++ non hanno però l'argomento permessi espliciti (modalità) specifico di POSIX.
Tuttavia, ecco una funzione C che può essere compilata con i compilatori 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 */
Le macro STRDUP() e FREE() sono versioni di controllo degli errori di strdup() e free() , dichiarato in emalloc.h (e implementato inemalloc.c e estrdup.c ).Il "sysstat.h" header si occupa delle versioni non funzionanti di <sys/stat.h> e può essere sostituito da <sys/stat.h> sui moderni sistemi Unix (ma ci sono stati molti problemi nel 1990). E "mkpath.h" dichiara mkpath() .
Il passaggio tra v1.12 (versione originale della risposta) e v1.13 (versione modificata della risposta) è stato il test per EEXIST indo_mkdir() .Ciò è stato segnalato come necessario daSwitch — grazie, Switch.Il codice di test è stato aggiornato e ha riprodotto il problema su un MacBookPro (Intel Core i7 a 2,3GHz, con Mac OS X 10.7.4) e suggerisce che il problema è stato risolto nel revisione (ma il testing può solo mostrare la presenza di bug, mai la loro assenza). Il codice mostrato è ora v1.16; sono state apportate modifiche estetiche o amministrative dalla v1.13 (come utilizzare mkpath.h invece di jlss.h eincludi <unistd.h> incondizionatamente solo nel codice di test). È ragionevole sostenere che "sysstat.h" dovrebbe essere sostituito da <sys/stat.h> a meno che tu non abbia un sistema insolitamente recalcitrante.
(Con la presente sei autorizzato a utilizzare questo codice per qualsiasi scopo con attribuzione.)
Questo codice è disponibile nel mio repository SOQ (Stack Overflow Questions) su GitHub come file mkpath.c emkpath.h (ecc.) nella sottodirectory src/so-0067-5039.