如何在 Win32 中递归创建文件夹？

Question

我正在尝试创建一个 function，它采用目录名称（ C:\foo\bar或..\foo\bar\..\baz或\\someserver\foo\bar ），并将目录创建为必要的，以便创建整个路径。

我自己正在尝试一个非常天真的实现，这似乎是一个字符串处理的噩梦。 有/ vs \ ，有 .network 共享的特殊情况，它以\\开头（你也不能尝试 mkdir() 路径的前两个级别，即机器名称和共享名称），并且有\.\键入可以存在于路径中的废话。

在 C++ 中是否存在一种简单的方法来执行此操作？

Answer 1

如果您不需要支持 Windows 2000 之前的 Windows 版本，您可以为此使用SHCreateDirectoryEx 函数。 考虑一下：

int createDirectoryRecursively( LPCTSTR path )
{
    return SHCreateDirectoryEx( NULL, path, NULL );
}

// ...
if ( createDirectoryRecursively( T("C:\\Foo\\Bar\\Baz") ) == ERROR_SUCCESS ) {
   // Bingo!
} 

如果使用这样的 shell32.dll API 成为一个问题，你总是可以用其他东西（可能是手动循环）重新实现上面的 createDirectoryRecursively 函数。

Answer 2

这是一个不使用外部库的版本，因此仅适用于 Win32，并且在所有版本的 Windows（包括 Windows CE，我需要它的地方）中都可以运行：

wchar_t *path = GetYourPathFromWherever();

wchar_t folder[MAX_PATH];
wchar_t *end;
ZeroMemory(folder, MAX_PATH * sizeof(wchar_t));

end = wcschr(path, L'\\');

while(end != NULL)
{
    wcsncpy(folder, path, end - path + 1);
    if(!CreateDirectory(folder, NULL))
    {
        DWORD err = GetLastError();

        if(err != ERROR_ALREADY_EXISTS)
        {
            // do whatever handling you'd like
        }
    }
    end = wcschr(++end, L'\\');
}

Answer 3

这是我编写的一个函数，它迭代地创建一个文件夹树。 这是主要功能：

#include <io.h>
#include <string>
#include <direct.h>
#include <list>

// Returns false on success, true on error
bool createFolder(std::string folderName) {
    list<std::string> folderLevels;
    char* c_str = (char*)folderName.c_str();

    // Point to end of the string
    char* strPtr = &c_str[strlen(c_str) - 1];

    // Create a list of the folders which do not currently exist
    do {
        if (folderExists(c_str)) {
            break;
        }
        // Break off the last folder name, store in folderLevels list
        do {
            strPtr--;
        } while ((*strPtr != '\\') && (*strPtr != '/') && (strPtr >= c_str));
        folderLevels.push_front(string(strPtr + 1));
        strPtr[1] = 0;
    } while (strPtr >= c_str);

    if (_chdir(c_str)) {
        return true;
    }

    // Create the folders iteratively
    for (list<std::string>::iterator it = folderLevels.begin(); it != folderLevels.end(); it++) {
        if (CreateDirectory(it->c_str(), NULL) == 0) {
            return true;
        }
        _chdir(it->c_str());
    }

    return false;
}

folderExists例程如下：

// Return true if the folder exists, false otherwise
bool folderExists(const char* folderName) {
    if (_access(folderName, 0) == -1) {
        //File not found
        return false;
    }

    DWORD attr = GetFileAttributes((LPCSTR)folderName);
    if (!(attr & FILE_ATTRIBUTE_DIRECTORY)) {
        // File is not a directory
        return false;
    }

    return true;
}

我测试上述函数的示例调用如下（并且它有效）：

createFolder("C:\\a\\b\\c\\d\\e\\f\\g\\h\\i\\j\\k\\l\\m\\n\\o\\p\\q\\r\\s\\t\\u\\v\\w\\x\\y\\z");

此功能尚未经过非常彻底的测试，我不确定它是否适用于其他操作系统（但可能与一些修改兼容）。 我目前在Windows 7.使用Visual Studio 2010 Windows 7.

Answer 4

SHCreateDirectory函数可以做到这一点。 但该文档指出，它可能会在更高版本的 Windows 中被弃用。

来自 MSDN

注意 此功能可通过 Windows XP Service Pack 2 (SP2) 和 Microsoft Windows Server 2003 使用。它可能会在 Windows 的后续版本中更改或不可用。

Answer 5

使用 C++17，这可以使用std::filesystem::create_directories()轻松完成。

例子：

#include <filesystem>
...

const char* path = "C:\\foo\\bar";
std::filesystem::create_directories(path);

Answer 6

好的例子：

#ifndef UNICODE
#define UNICODE
#define UNICODE_WAS_UNDEFINED
#endif

#include <Windows.h>

#ifdef UNICODE_WAS_UNDEFINED
#undef UNICODE
#endif

#include <string>

BOOL DirectoryExists(LPCTSTR szPath)
{
  DWORD dwAttrib = GetFileAttributes(szPath);

  return (dwAttrib != INVALID_FILE_ATTRIBUTES &&
    (dwAttrib & FILE_ATTRIBUTE_DIRECTORY));
}

void createDirectoryRecursively(std::wstring path)
{
  signed int pos = 0;
  do
  {
    pos = path.find_first_of(L"\\/", pos + 1);
    CreateDirectory(path.substr(0, pos).c_str(), NULL);
  } while (pos != std::wstring::npos);
}

//in application
int main()
{
  std::wstring directory = L"../temp/dir";
  if (DirectoryExists(directory.c_str()) == FALSE)
    createDirectoryRecursively(directory);
  return 0;
}

Answer 7

对于 Windows XP 及更高版本。 需要宽字符空终止字符串和递归操作的数量作为参数。 尚未测试超过 1 个级别。

注意：路径分隔符必须是“\\”

bool CreateRecursiveDirectoryW(const wchar_t* filepath, const int max_level)
{
    bool result = false;
    wchar_t path_copy[MAX_PATH] = {0};
    wcscat_s(path_copy, MAX_PATH, filepath);
    std::vector<std::wstring> path_collection;

    for(int level=0; PathRemoveFileSpecW(path_copy) && level < max_level; level++)
    {
        path_collection.push_back(path_copy);
    }
    for(int i=path_collection.size()-1; i >= 0; i--)
    {
        if(!PathIsDirectoryW(path_collection[i].c_str()))
            if(CreateDirectoryW(path_collection[i].c_str(), NULL))
                result = true;
    }
    return result;
};

Answer 8

ctacke 你忘记了最后一段。 例如 '\\aa\\bb\\"cc"' 以下是对 ctacke 的修改：

//---------------------------------------------------------------------
int isfexist(char *fn)
{
    struct stat stbuf;
    extern int errno;

    if (stat(fn, &stbuf)) {
        if (errno == ENOENT) return(0);
        else {
            printf("isfexist: stat");
            return(0);
        }
    } else {
        if (stbuf.st_mode & S_IFDIR) return(2);
        else return(1);
    }
}
//---------------------------------------------------------------------
int MakeDirTree(char *path)
{
    char *end1, *end2;

    if (path[0] == '\\') end1 = path + 1;       // Case '\aa\bb'
    else if (path[1] == ':' && path[2] == '\\') end1 = path + 3;    // Case 'C:\\aa\\bb'
    else end1 = path;

    for(;;) {
        end2 = strchr(end1, '\\');
        if (end2 == NULL) {
            // Case '\aa\bb\'
            if (*end1 == 0) break;
            // Last segment '\aa\bb\"cc"' not yet proceed
        } else *end2 = 0;
        if (isfexist(path) <= 0) mkdir(path);
        if (end2 == NULL) break;    // Last segment finished
        else {
            *end2 = '\\';
            end1 = end2 + 1;
        }
    }
}

Answer 9

我正在修改一个旧的 Windows CE 应用程序，这就是我打算使用的。 也应该在 Windows CE 中工作。 这实际上也是递归的：

static void createPath(const CString& p)
{
   // only create directories that don't exist
   if (::GetFileAttributes(p) == INVALID_FILE_ATTRIBUTES)
   {
      // check if our parent needs to be created, too...
      int i = p.ReverseFind('\\');
      if (i > 0)
      {
         // ...yes, create the parent (recursively)
         createPath(p.Left(i));
      }

      // finally, actually create the directory in p
      ::CreateDirectory(p, NULL);
   }
}

Answer 10

UnicodeString path = "C:\\Test\\Test\\Test\\";
TStringList *list = new TStringList();

try
{
    list->Delimiter = '\\';
    list->StrictDelimiter = true;
    list->DelimitedText = path;
    path = list->Strings[0]; \\drive letter
    for(int i = 1; i < list->Count - 1; i++)
    {
        try
        {
            path += "\\" + list->Strings[i];
            CreateDirectory(path.w_str(), NULL);
        }
        catch(...) { }
    }
}
catch(...) { }
delete list;

Answer 11

如果您使用的是 Microsoft 的Windows 实现库 (WIL) ，则可以使用wil::CreateDirectoryDeep函数。 如果没有，您可能需要考虑使用它，或借用代码。

Answer 12

从http://www.cplusplus.com/reference/string/string/find_last_of/ ：

// string::find_last_of
#include <iostream>
#include <string>
using namespace std;

void SplitFilename (const string& str)
{
  size_t found;
  cout << "Splitting: " << str << endl;
  found=str.find_last_of("/\\");
  cout << " folder: " << str.substr(0,found) << endl;
  cout << " file: " << str.substr(found+1) << endl;
}

int main ()
{
  string str1 ("/usr/bin/man");
  string str2 ("c:\\windows\\winhelp.exe");

  SplitFilename (str1);
  SplitFilename (str2);

  return 0;

这应该让您了解如何处理路径字符串。 然后，您需要做的就是遍历从驱动器开始到最深文件夹的路径。 检查文件夹是否存在，如果不存在，则创建它。

Answer 13

这是我的代码示例（复制自How can I create directory tree in C++/Linux? ）。 也许它不符合第一篇文章的所有要求，但很好，它适用于 Windows 和 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;
}

用法：

d:\Work\c++\make_path> makePath 1/2 folderA/folderB/folderC
creating 1/2 ... OK
creating folderA/folderB/folderC ... OK

Answer 14

下面的方法帮助我创建了几个目录，直到实现了整个路径。

假设你有：

C:\\d1并传递C:\\d1\\d2\\d3作为参数。

这个函数会继续在d1创建d2 ，在d2创建d3 。 此外，它不会弄乱d1目录中已经存在的文件。

// HRESULT CreateDirectoryStructure(directoryPath)

std::wstring directoryPath;
directoryPath= L"C:\\d1\\d2\\d3";
hr = CreateDirectoryStructure(directoryPath);

Answer 15

void createFolders(const std::string &s, char delim) {
    std::stringstream ss(s);
    std::string item;
    char combinedName[50]={'\0'};
    while (std::getline(ss, item, delim)) { 
        sprintf(combinedName,"%s%s%c",combinedName,item.c_str(),delim);
        cout<<combinedName<<endl;

        struct stat st = {0};
                 if (stat(combinedName,&st)==-1)
                 { 
            #if REDHAT
                     mkdir(combinedName,0777);
            #else
                      CreateDirectory(combinedName,NULL);
            #endif
                 }


     }
}

Answer 16

注意：这个答案有点快速和肮脏，并且不能处理所有情况。 如果这对你没问题，请继续阅读。 如果没有，请考虑使用其他选项之一。

---

您可以为此使用旧的 mkdir。 赶紧跑

system("mkdir " + strPath);

你就完成了。

嗯，差不多。 仍然有一些情况您必须处理，例如网络共享（可能不起作用）和反斜杠。 但是当使用相对安全的路径时，您可以使用这种较短的形式。

您可能会发现另一件有用的东西是_fullpath() ，它可以将给定的路径解析为完整且干净的路径。 知道你有一个干净的路径，你应该可以编写一个相当简单的递归函数来一个一个地创建文件夹，即使在处理 UNC 路径时也是如此。