C++文件系统操作6 - 跨平台实现文件和文件夹的拷贝

知者何南  金牌会员 | 2024-7-26 21:55:08 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 884|帖子 884|积分 2652

1. 关键词

C++ 文件系统操作 拷贝文件 拷贝文件夹 跨平台
2. fileutil.h
  1. #pragma once
  3. #include <string>
  4. #include <cstdio>
  5. #include <cstdint>
  6. #include "filetype.h"
  7. #include "filepath.h"
  9. namespace cutl
  10. {
  12.     /**
  13.      * @brief The file guard class to manage the FILE pointer automatically.
  14.      * file_guard object can close the FILE pointer automatically when his scope is exit.
  15.      */
  16.     class file_guard
  17.     {
  18.     public:
  19.         /**
  20.          * @brief Construct a new file guard object
  21.          *
  22.          * @param file the pointer of the FILE object
  23.          */
  24.         explicit file_guard(FILE *file);
  26.         /**
  27.          * @brief Destroy the file guard object
  28.          *
  29.          */
  30.         ~file_guard();
  32.         /**
  33.          * @brief Get the FILE pointer.
  34.          *
  35.          * @return FILE*
  36.          */
  37.         FILE *getfd() const;
  39.     private:
  40.         FILE *file_;
  41.     };
  43.     /**
  44.      * @brief Copy a file or symbolic link(shortcut on windows).
  45.      *
  46.      * @param srcpath the filepath of the source file or symbolic link to be copied
  47.      * @param dstpath the filepath of the destination file or symbolic link to be copied to
  48.      * @param attributes whether to copy the file attributes, default is false.
  49.      * If true, means copy the file attributes, like the 'cp -p' command.
  50.      * @return true if the file or symbolic link is copied successfully, false otherwise.
  51.      * @note If the destination file or directory already exists, it will be overwritten.
  52.      * @return false
  53.      */
  54.     bool copyfile(const filepath &srcpath, const filepath &dstpath, bool attributes = false);
  56.     // copy directory recursively
  57.     /**
  58.      * @brief Copy a directory recursively.
  59.      *
  60.      * @param srcdir the filepath of the source directory to be copied
  61.      * @param dstdir the filepath of the destination directory to be copied to
  62.      * @return true if the directory is copied successfully, false otherwise.
  63.      * @note If the destination directory already exists, it will be overwritten.
  64.      */
  65.     bool copydir(const filepath &srcdir, const filepath &dstdir);
  67. } // namespace cutl
复制代码
3. fileutil.cpp
  1. #include <cstdio>
  2. #include <map>
  3. #include <iostream>
  4. #include <cstring>
  5. #include <sys/stat.h>
  6. #include "fileutil.h"
  7. #include "inner/logger.h"
  8. #include "inner/filesystem.h"
  9. #include "strutil.h"
  11. namespace cutl
  12. {
  13.     file_guard::file_guard(FILE *file)
  14.         : file_(file)
  15.     {
  16.     }
  18.     file_guard::~file_guard()
  19.     {
  20.         if (file_)
  21.         {
  22.             // CUTL_DEBUG("close file");
  23.             int ret = fclose(file_);
  24.             if (ret != 0)
  25.             {
  26.                 CUTL_ERROR("fail to close file, ret" + std::to_string(ret));
  27.             }
  28.             file_ = nullptr;
  29.         }
  30.         // ROBOLOG_DCHECK(file_ == nullptr);
  31.     }
  33.     FILE *file_guard::getfd() const
  34.     {
  35.         return file_;
  36.     }
  38.     bool copyfile(const filepath &srcpath, const filepath &dstpath, bool attributes)
  39.     {
  40.         // CUTL_INFO("file type: " + std::to_string(srcpath.type()) + ", " + filetype_flag(srcpath.type()) + ", " + srcpath.str() + ", dstpath:" + dstpath.str());
  42.         // copy file content
  43.         if (srcpath.isfile())
  44.         {
  45.             if (dstpath.exists())
  46.             {
  47.                 // remove if exists
  48.                 removefile(dstpath);
  49.             }
  50.             file_guard frd(fopen(srcpath.str().c_str(), "rb"));
  51.             if (frd.getfd() == nullptr)
  52.             {
  53.                 CUTL_ERROR("open file failed, " + srcpath.str());
  54.                 return false;
  55.             }
  56.             file_guard fwt(fopen(dstpath.str().c_str(), "wb"));
  57.             if (fwt.getfd() == nullptr)
  58.             {
  59.                 CUTL_ERROR("open file failed, " + dstpath.str());
  60.                 return false;
  61.             }
  63.             static constexpr size_t buf_size = 8 * 1024;
  64.             uint8_t buffer[buf_size] = {0};
  65.             size_t read_len = 0;
  66.             size_t write_len = 0;
  67.             while ((read_len = fread(buffer, 1, buf_size, frd.getfd())) > 0)
  68.             {
  69.                 write_len = fwrite(buffer, 1, read_len, fwt.getfd());
  70.                 if (write_len != read_len)
  71.                 {
  72.                     CUTL_ERROR("write file failed, only write " + std::to_string(write_len) + ", read_len:" + std::to_string(read_len));
  73.                     return false;
  74.                 }
  75.             }
  76.             // flush file to disk
  77.             int ret = fflush(fwt.getfd());
  78.             if (0 != ret)
  79.             {
  80.                 CUTL_ERROR("fail to flush file:" + dstpath.str());
  81.                 return false;
  82.             }
  83.             if (!file_sync(fwt.getfd()))
  84.             {
  85.                 CUTL_ERROR("file_sync failed for " + dstpath.str());
  86.                 return false;
  87.             }
  88.         }
  89.         else if (srcpath.issymlink())
  90.         {
  91.             if (dstpath.exists())
  92.             {
  93.                 // remove if exists
  94.                 file_removelink(dstpath.str());
  95.             }
  96.             auto link_path = file_readlink(srcpath.str());
  97.             if (link_path.empty())
  98.             {
  99.                 CUTL_ERROR("readlink failed for " + srcpath.str());
  100.                 return false;
  101.             }
  102.             if (!file_createlink(link_path, dstpath.str()))
  103.             {
  104.                 CUTL_ERROR("createlink failed for " + dstpath.str());
  105.                 return false;
  106.             }
  107.         }
  108.         else
  109.         {
  110.             CUTL_ERROR("not a file or symlink, cannot copy: [" + filetype_flag(srcpath.type()) + "]" + srcpath.str());
  111.             return false;
  112.         }
  114.         // copy file attributes
  115.         if (attributes && srcpath.isfile())
  116.         {
  117.             return copy_attributes(srcpath.str(), dstpath.str());
  118.         }
  120.         return true;
  121.     }
  123.     // https://www.cnblogs.com/harrypotterjackson/p/12113382.html
  124.     bool copydir(const filepath &srcdir, const filepath &dstdir)
  125.     {
  126.         if (!srcdir.isdir())
  127.         {
  128.             CUTL_ERROR("srcdir is not a directory: " + srcdir.str());
  129.             return false;
  130.         }
  132.         if (!dstdir.exists() && !createdir(dstdir, true))
  133.         {
  134.             CUTL_ERROR("createdir failed for " + dstdir.str());
  135.             return false;
  136.         }
  138.         auto filelist = list_files(srcdir, filetype::all, true);
  139.         for (size_t i = 0; i < filelist.size(); i++)
  140.         {
  141.             auto file = filelist[i];
  142.             auto src_file = file.filepath;
  143.             auto reletive_path = src_file.substr(srcdir.str().length() + 1);
  144.             auto dstpath = dstdir.join(reletive_path);
  145.             auto srcpath = cutl::path(src_file);
  146.             if (file.type == filetype::file || file.type == filetype::symlink)
  147.             {
  148.                 if (!copyfile(srcpath, dstpath, true))
  149.                 {
  150.                     return false;
  151.                 }
  152.             }
  153.             else if (file.type == filetype::directory)
  154.             {
  155.                 if (!createdir(dstpath, true))
  156.                 {
  157.                     return false;
  158.                 }
  160.                 if (!copy_attributes(src_file, dstpath.str(), true))
  161.                 {
  162.                     return false;
  163.                 }
  164.             }
  165.             else
  166.             {
  167.                 CUTL_WARN("the file cannot be copy: [" + filetype_flag(srcpath.type()) + "]" + srcpath.str());
  168.                 continue;
  169.             }
  170.         }
  172.         return true;
  173.     }
复制代码
4. filesystem_win.h
  1. #include <vector>
  2. #include <string>
  4. #pragma once
  6. namespace cutl
  7. {
  8.     // 拷贝文件/文件夹的属性，isdir参数只在windows下生效,Unix-like系统下不起作用
  9.     bool copy_attributes(const std::string &srcpath, const std::string &dstpath, bool isdir = false);
  10. } // namespace cutl
复制代码
5. filesystem_win.cpp
  1. #if defined(_WIN32) || defined(__WIN32__)
  3. #include <io.h>
  4. #include <direct.h>
  5. #include <Windows.h>
  6. #include <stdlib.h>
  7. #include "strutil.h"
  8. #include "filesystem.h"
  9. #include "logger.h"
  11. namespace cutl
  12. {
  13.     bool copy_attributes(const std::string &srcpath, const std::string &dstpath, bool isdir)
  14.     {
  15.         // 获取 修改访问、修改时间
  16.         FILETIME t_create, t_access, t_write;
  17.         HANDLE h_src = NULL;
  18.         if (isdir)
  19.         {
  20.             // 文件夹
  21.             h_src = CreateFile(
  22.                 srcpath.c_str(),
  23.                 GENERIC_READ,
  24.                 FILE_SHARE_READ | FILE_SHARE_DELETE,
  25.                 NULL,
  26.                 OPEN_EXISTING,
  27.                 FILE_FLAG_BACKUP_SEMANTICS,
  28.                 NULL);
  29.         }
  30.         else
  31.         {
  32.             h_src = CreateFileA(
  33.                 srcpath.c_str(),
  34.                 GENERIC_READ,
  35.                 0,
  36.                 NULL,
  37.                 OPEN_EXISTING,
  38.                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS,
  39.                 NULL);
  40.         }
  42.         if (h_src == INVALID_HANDLE_VALUE)
  43.         {
  44.             CUTL_ERROR("Failed to open file " + srcpath + ", error code: " + std::to_string(GetLastError()));
  45.             CloseHandle(h_src);
  46.             return false;
  47.         }
  48.         if (!GetFileTime(h_src, &t_create, &t_access, &t_write))
  49.         {
  50.             CUTL_ERROR("Failed to get file times for " + srcpath + ", error code: " + std::to_string(GetLastError()));
  51.             CloseHandle(h_src);
  52.             return false;
  53.         }
  54.         CloseHandle(h_src);
  56.         // 设置 修改访问、修改时间
  57.         HANDLE h_dst = NULL;
  58.         if (isdir)
  59.         {
  60.             h_dst = CreateFile(
  61.                 dstpath.c_str(),
  62.                 GENERIC_READ | GENERIC_WRITE,
  63.                 FILE_SHARE_READ | FILE_SHARE_DELETE,
  64.                 NULL,
  65.                 OPEN_EXISTING,
  66.                 FILE_FLAG_BACKUP_SEMANTICS,
  67.                 NULL);
  68.         }
  69.         else
  70.         {
  71.             h_dst = ::CreateFileA(
  72.                 dstpath.c_str(),
  73.                 // GENERIC_WRITE,
  74.                 // GENERIC_READ | GENERIC_WRITE,
  75.                 GENERIC_ALL,
  76.                 0,
  77.                 NULL,
  78.                 OPEN_EXISTING,
  79.                 FILE_ATTRIBUTE_NORMAL,
  80.                 NULL);
  81.         }
  83.         if (h_dst == INVALID_HANDLE_VALUE)
  84.         {
  85.             CUTL_ERROR("Failed to open file " + dstpath + ", error code: " + std::to_string(GetLastError()));
  86.             CloseHandle(h_dst);
  87.             return false;
  88.         }
  89.         if (!SetFileTime(h_dst, &t_create, &t_access, &t_write))
  90.         {
  91.             CUTL_ERROR("Failed to set file times for " + dstpath + ", error code: " + std::to_string(GetLastError()));
  92.             CloseHandle(h_dst);
  93.             return false;
  94.         }
  95.         CloseHandle(h_dst);
  97.         // 修改文件属性
  98.         // 注意：文件访问权限的属性设置要放在文件时间的修改后面，因为只读权限的文件不允许修改时间
  99.         DWORD attributes = GetFileAttributesA(srcpath.c_str());
  100.         if (attributes == INVALID_FILE_ATTRIBUTES)
  101.         {
  102.             CUTL_ERROR("Failed to get file attributes for " + srcpath + ", error code: " + std::to_string(GetLastError()));
  103.             return false;
  104.         }
  105.         if (!SetFileAttributesA(dstpath.c_str(), attributes))
  106.         {
  107.             CUTL_ERROR("Failed to set file attributes for " + dstpath + ", error code: " + std::to_string(GetLastError()));
  108.             return false;
  109.         }
  110.         return true;
  111.     }
  112. } // namespace cutl
  114. #endif // defined(_WIN32) || defined(__WIN32__)
复制代码
6. filesystem_unix.cpp
  1. #if defined(_WIN32) || defined(__WIN32__)
  2. // do nothing
  3. #else
  5. #include <unistd.h>
  6. #include <sys/stat.h>
  7. #include <dirent.h>
  8. #include <stack>
  9. #include <cstring>
  10. #include <utime.h>
  11. #include <stdlib.h>
  12. #include <sys/time.h>
  13. #include "filesystem.h"
  14. #include "inner/logger.h"
  16. namespace cutl
  17. {
  18.     bool copy_attributes(const std::string &srcpath, const std::string &dstpath, bool isdir)
  19.     {
  20.         struct stat attr_of_src;
  21.         int ret = lstat(srcpath.c_str(), &attr_of_src);
  22.         if (ret != 0)
  23.         {
  24.             CUTL_ERROR("lstat error. srcpath:" + srcpath + ", error:" + strerror(errno));
  25.             return false;
  26.         }
  28.         // 修改文件属性
  29.         ret = chmod(dstpath.c_str(), attr_of_src.st_mode);
  30.         if (ret != 0)
  31.         {
  32.             CUTL_ERROR("chmod error. dstpath:" + dstpath + ", error:" + strerror(errno));
  33.             return false;
  34.         }
  35.         // 修改文件用户组
  36.         ret = chown(dstpath.c_str(), attr_of_src.st_uid, attr_of_src.st_gid);
  37.         if (ret != 0)
  38.         {
  39.             CUTL_ERROR("chown error. dstpath:" + dstpath + ", error:" + strerror(errno));
  40.             return false;
  41.         }
  43.         // 修改文件访问、修改时间
  44.         if (S_ISLNK(attr_of_src.st_mode))
  45.         {
  46.             // TODO: 编译还有问题，需要确定编译宏
  47.             // struct timeval time_buf[2];
  48.             // time_buf[0].tv_sec = attr_of_src.st_atim.tv_sec;
  49.             // time_buf[0].tv_usec = attr_of_src.st_atim.tv_nsec / 1000;
  50.             // time_buf[1].tv_sec = attr_of_src.st_mtim.tv_sec;
  51.             // time_buf[1].tv_usec = attr_of_src.st_mtim.tv_nsec / 1000;
  52.             // ret = lutimes(dstpath.c_str(), time_buf);
  53.             // if (ret != 0)
  54.             // {
  55.             //     CUTL_ERROR("lutimes error. dstpath:" + dstpath + ", error:" + strerror(errno));
  56.             //     return false;
  57.             // }
  58.         }
  59.         else
  60.         {
  61.             struct utimbuf tbuf;
  62.             tbuf.actime = attr_of_src.st_atime;
  63.             tbuf.modtime = attr_of_src.st_mtime;
  64.             ret = utime(dstpath.c_str(), &tbuf);
  65.             if (ret != 0)
  66.             {
  67.                 CUTL_ERROR("utime error. dstpath:" + dstpath + ", error:" + strerror(errno));
  68.                 return false;
  69.             }
  70.         }
  72.         return true;
  73.     }
  74. } // namespace cutl
  76. #endif // defined(_WIN32) || defined(__WIN32__)
复制代码
7. 源码地点

更多详细代码，请查看本人写的C++ 通用工具库: common_util, 本项目已开源，代码简便，且有详细的文档和Demo。
【SunLogging】
扫码二维码，关注微信公众号，阅读更多精彩内容
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

知者何南

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表