经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C++ » 查看文章
C/C++ Zlib库封装MyZip压缩类
来源：cnblogs　　作者：微软技术分享　　时间：2023/11/29 16:15:30　　对本文有异议

Zlib是一个开源的数据压缩库，提供了一种通用的数据压缩和解压缩算法。它最初由Jean-Loup Gailly和Mark Adler开发，旨在成为一个高效、轻量级的压缩库，其被广泛应用于许多领域，包括网络通信、文件压缩、数据库系统等。其压缩算法是基于DEFLATE算法，这是一种无损数据压缩算法，通常能够提供相当高的压缩比。

在软件开发中，文件的压缩和解压缩是一项常见的任务，而ZIP是一种被广泛应用的压缩格式。为了方便地处理ZIP压缩和解压缩操作，开发者通常使用各种编程语言和库来实现这些功能。本文将聚焦于一个简化的C++实现，通过分析代码，我们将深入了解其设计和实现细节。

类的功能实现

MyZip类旨在提供简单易用的ZIP压缩和解压缩功能。通过成员函数Compress和UnCompress，该类使得对目录的ZIP压缩和ZIP文件的解压变得相对容易。

ZIP压缩函数 Compress

Compress函数通过zlib库提供的ZIP压缩功能，递归地将目录下的文件添加到ZIP文件中。其中，nyCollectfileInDirtoZip函数负责遍历目录，而nyAddfiletoZip函数则用于添加文件到ZIP中。这种设计使得代码模块化，易于理解。

ZIP解压函数 UnCompress

UnCompress函数通过zlib库提供的ZIP解压功能，将ZIP文件解压到指定目录。函数中使用了unz系列函数来遍历ZIP文件中的文件信息，并根据文件类型进行相应的处理。这包括创建目录和写入文件，使得解压后的目录结构与ZIP文件一致。

将如上的压缩与解压方法封装成MyZip类，调用zip.Compress()实现压缩目录，调用zip.UnCompress()则实现解压缩目录。这些函数使用了zlib库的ZIP压缩和解压缩功能，并可以在项目中被应用，该类代码如下所示；

  1. #define ZLIB_WINAPI
  2. #include <string>
  3. #include <iostream>
  4. #include <vector>
  5. #include <Shlwapi.h> 
  6. #include <zip.h>
  7. #include <unzip.h>
  8. #include <zlib.h>
  10. using namespace std;
  12. #pragma comment(lib, "Shlwapi.lib")
  13. #pragma comment(lib, "zlibstat.lib")
  15. class MyZip
  16. {
  17. private:
  18.   // 向ZIP文件中添加文件
  19.   bool nyAddfiletoZip(zipFile zfile, const std::string& fileNameinZip, const std::string& srcfile)
  20.   {
  21.     if (NULL == zfile || fileNameinZip.empty())
  22.     {
  23.       return false;
  24.     }
  26.     int nErr = 0;
  27.     zip_fileinfo zinfo = { 0 };
  28.     tm_zip tmz = { 0 };
  29.     zinfo.tmz_date = tmz;
  30.     zinfo.dosDate = 0;
  31.     zinfo.internal_fa = 0;
  32.     zinfo.external_fa = 0;
  34.     // 构建新文件名
  35.     char sznewfileName[MAX_PATH] = { 0 };
  36.     memset(sznewfileName, 0x00, sizeof(sznewfileName));
  37.     strcat_s(sznewfileName, fileNameinZip.c_str());
  38.     if (srcfile.empty())
  39.     {
  40.       strcat_s(sznewfileName, "\\");
  41.     }
  43.     // 在ZIP中打开新文件
  44.     nErr = zipOpenNewFileInZip(zfile, sznewfileName, &zinfo, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION);
  45.     if (nErr != ZIP_OK)
  46.     {
  47.       return false;
  48.     }
  50.     // 如果有源文件，读取并写入ZIP文件
  51.     if (!srcfile.empty())
  52.     {
  53.       FILE* srcfp = _fsopen(srcfile.c_str(), "rb", _SH_DENYNO);
  54.       if (NULL == srcfp)
  55.       {
  56.         return false;
  57.       }
  59.       int numBytes = 0;
  60.       char* pBuf = new char[1024 * 100];
  61.       if (NULL == pBuf)
  62.       {
  63.         return false;
  64.       }
  66.       // 逐块读取源文件并写入ZIP
  67.       while (!feof(srcfp))
  68.       {
  69.         memset(pBuf, 0x00, sizeof(pBuf));
  70.         numBytes = fread(pBuf, 1, sizeof(pBuf), srcfp);
  71.         nErr = zipWriteInFileInZip(zfile, pBuf, numBytes);
  72.         if (ferror(srcfp))
  73.         {
  74.           break;
  75.         }
  76.       }
  78.       delete[] pBuf;
  79.       fclose(srcfp);
  80.     }
  82.     // 关闭ZIP文件中的当前文件
  83.     zipCloseFileInZip(zfile);
  85.     return true;
  86.   }
  88.   // 递归地将目录下的文件添加到ZIP
  89.   bool nyCollectfileInDirtoZip(zipFile zfile, const std::string& filepath, const std::string& parentdirName)
  90.   {
  91.     if (NULL == zfile || filepath.empty())
  92.     {
  93.       return false;
  94.     }
  96.     bool bFile = false;
  97.     std::string relativepath = "";
  98.     WIN32_FIND_DATAA findFileData;
  100.     char szpath[MAX_PATH] = { 0 };
  101.     if (::PathIsDirectoryA(filepath.c_str()))
  102.     {
  103.       strcpy_s(szpath, sizeof(szpath) / sizeof(szpath[0]), filepath.c_str());
  104.       int len = strlen(szpath) + strlen("\\*.*") + 1;
  105.       strcat_s(szpath, len, "\\*.*");
  106.     }
  107.     else
  108.     {
  109.       bFile = true;
  110.       strcpy_s(szpath, sizeof(szpath) / sizeof(szpath[0]), filepath.c_str());
  111.     }
  113.     HANDLE hFile = ::FindFirstFileA(szpath, &findFileData);
  114.     if (NULL == hFile)
  115.     {
  116.       return false;
  117.     }
  119.     do
  120.     {
  121.       // 构建相对路径
  122.       if (parentdirName.empty())
  123.         relativepath = findFileData.cFileName;
  124.       else
  125.         relativepath = parentdirName + "\\" + findFileData.cFileName;
  127.       // 如果是目录，递归处理子目录
  128.       if (findFileData.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
  129.       {
  130.         if (strcmp(findFileData.cFileName, ".") != 0 && strcmp(findFileData.cFileName, "..") != 0)
  131.         {
  132.           nyAddfiletoZip(zfile, relativepath, "");
  134.           char szTemp[MAX_PATH] = { 0 };
  135.           strcpy_s(szTemp, filepath.c_str());
  136.           strcat_s(szTemp, "\\");
  137.           strcat_s(szTemp, findFileData.cFileName);
  138.           nyCollectfileInDirtoZip(zfile, szTemp, relativepath);
  139.         }
  140.         continue;
  141.       }
  143.       char szTemp[MAX_PATH] = { 0 };
  144.       if (bFile)
  145.       {
  146.         strcpy_s(szTemp, filepath.c_str());
  147.       }
  148.       else
  149.       {
  150.         strcpy_s(szTemp, filepath.c_str());
  151.         strcat_s(szTemp, "\\");
  152.         strcat_s(szTemp, findFileData.cFileName);
  153.       }
  155.       // 将文件添加到ZIP
  156.       nyAddfiletoZip(zfile, relativepath, szTemp);
  158.     } while (::FindNextFileA(hFile, &findFileData));
  160.     FindClose(hFile);
  162.     return true;
  163.   }
  165.   // 替换字符串中的所有指定子串
  166.   std::string& replace_all(std::string& str, const std::string& old_value, const std::string& new_value)
  167.   {
  168.     while (true)
  169.     {
  170.       std::string::size_type pos(0);
  171.       if ((pos = str.find(old_value)) != std::string::npos)
  172.         str.replace(pos, old_value.length(), new_value);
  173.       else
  174.         break;
  175.     }
  176.     return str;
  177.   }
  179.   // 创建多级目录
  180.   BOOL CreatedMultipleDirectory(const std::string& direct)
  181.   {
  182.     std::string Directoryname = direct;
  183.     if (Directoryname[Directoryname.length() - 1] != '\\')
  184.     {
  185.       Directoryname.append(1, '\\');
  186.     }
  188.     std::vector< std::string> vpath;
  189.     std::string strtemp;
  190.     BOOL  bSuccess = FALSE;
  192.     // 遍历目录字符串，逐级创建目录
  193.     for (int i = 0; i < Directoryname.length(); i++)
  194.     {
  195.       if (Directoryname[i] != '\\')
  196.       {
  197.         strtemp.append(1, Directoryname[i]);
  198.       }
  199.       else
  200.       {
  201.         vpath.push_back(strtemp);
  202.         strtemp.append(1, '\\');
  203.       }
  204.     }
  206.     std::vector< std::string>::iterator vIter = vpath.begin();
  207.     for (; vIter != vpath.end(); vIter++)
  208.     {
  209.       bSuccess = CreateDirectoryA(vIter->c_str(), NULL) ? TRUE : FALSE;
  210.     }
  212.     return bSuccess;
  213.   }
  215. public:
  216.   // 压缩目录
  217.   bool Compress(const std::string& dirpathName, const std::string& zipfileName, const std::string& parentdirName)
  218.   {
  219.     bool bRet = false;
  220.     zipFile zFile = NULL;
  222.     // 根据ZIP文件是否存在选择打开方式
  223.     if (!::PathFileExistsA(zipfileName.c_str()))
  224.     {
  225.       zFile = zipOpen(zipfileName.c_str(), APPEND_STATUS_CREATE);
  226.     }
  227.     else
  228.     {
  229.       zFile = zipOpen(zipfileName.c_str(), APPEND_STATUS_ADDINZIP);
  230.     }
  232.     if (NULL == zFile)
  233.     {
  234.       return bRet;
  235.     }
  237.     // 将目录下的文件添加到ZIP
  238.     if (nyCollectfileInDirtoZip(zFile, dirpathName, parentdirName))
  239.     {
  240.       bRet = true;
  241.     }
  243.     zipClose(zFile, NULL);
  245.     return bRet;
  246.   }
  248.   // 解压目录
  249.   bool UnCompress(const std::string& strFilePath, const std::string& strTempPath)
  250.   {
  251.     int nReturnValue;
  252.     string tempFilePath;
  253.     string srcFilePath(strFilePath);
  254.     string destFilePath;
  256.     // 打开ZIP文件
  257.     unzFile unzfile = unzOpen(srcFilePath.c_str());
  258.     if (unzfile == NULL)
  259.     {
  260.       return false;
  261.     }
  263.     unz_global_info* pGlobalInfo = new unz_global_info;
  264.     nReturnValue = unzGetGlobalInfo(unzfile, pGlobalInfo);
  265.     if (nReturnValue != UNZ_OK)
  266.     {
  267.       return false;
  268.     }
  270.     unz_file_info* pFileInfo = new unz_file_info;
  271.     char szZipFName[MAX_PATH] = { 0 };
  272.     char szExtraName[MAX_PATH] = { 0 };
  273.     char szCommName[MAX_PATH] = { 0 };
  275.     for (int i = 0; i < pGlobalInfo->number_entry; i++)
  276.     {
  277.       nReturnValue = unzGetCurrentFileInfo(unzfile, pFileInfo, szZipFName, MAX_PATH, szExtraName, MAX_PATH, szCommName, MAX_PATH);
  278.       if (nReturnValue != UNZ_OK)
  279.         return false;
  281.       string strZipFName = szZipFName;
  283.       // 如果是目录，创建相应目录
  284.       if (pFileInfo->external_fa == FILE_ATTRIBUTE_DIRECTORY || (strZipFName.rfind('/') == strZipFName.length() - 1))
  285.       {
  286.         destFilePath = strTempPath + "//" + szZipFName;
  287.         CreateDirectoryA(destFilePath.c_str(), NULL);
  288.       }
  289.       else
  290.       {
  291.         string strFullFilePath;
  292.         tempFilePath = strTempPath + "/" + szZipFName;
  293.         strFullFilePath = tempFilePath;
  295.         int nPos = tempFilePath.rfind("/");
  296.         int nPosRev = tempFilePath.rfind("\\");
  297.         if (nPosRev == string::npos && nPos == string::npos)
  298.           continue;
  300.         size_t nSplitPos = nPos > nPosRev ? nPos : nPosRev;
  301.         destFilePath = tempFilePath.substr(0, nSplitPos + 1);
  303.         // 创建多级目录
  304.         if (!PathIsDirectoryA(destFilePath.c_str()))
  305.         {
  306.           destFilePath = replace_all(destFilePath, "/", "\\");
  307.           int bRet = CreatedMultipleDirectory(destFilePath);
  308.         }
  310.         strFullFilePath = replace_all(strFullFilePath, "/", "\\");
  312.         // 创建文件并写入数据
  313.         HANDLE hFile = CreateFileA(strFullFilePath.c_str(), GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_WRITE_THROUGH, NULL);
  314.         if (hFile == INVALID_HANDLE_VALUE)
  315.         {
  316.           return false;
  317.         }
  319.         nReturnValue = unzOpenCurrentFile(unzfile);
  320.         if (nReturnValue != UNZ_OK)
  321.         {
  322.           CloseHandle(hFile);
  323.           return false;
  324.         }
  326.         uLong BUFFER_SIZE = pFileInfo->uncompressed_size;
  327.         void* szReadBuffer = NULL;
  328.         szReadBuffer = (char*)malloc(BUFFER_SIZE);
  329.         if (NULL == szReadBuffer)
  330.         {
  331.           break;
  332.         }
  334.         // 逐块读取ZIP文件并写入目标文件
  335.         while (TRUE)
  336.         {
  337.           memset(szReadBuffer, 0, BUFFER_SIZE);
  338.           int nReadFileSize = 0;
  340.           nReadFileSize = unzReadCurrentFile(unzfile, szReadBuffer, BUFFER_SIZE);
  342.           if (nReadFileSize < 0)
  343.           {
  344.             unzCloseCurrentFile(unzfile);
  345.             CloseHandle(hFile);
  346.             return false;
  347.           }
  348.           else if (nReadFileSize == 0)
  349.           {
  350.             unzCloseCurrentFile(unzfile);
  351.             CloseHandle(hFile);
  352.             break;
  353.           }
  354.           else
  355.           {
  356.             DWORD dWrite = 0;
  357.             BOOL bWriteSuccessed = WriteFile(hFile, szReadBuffer, BUFFER_SIZE, &dWrite, NULL);
  358.             if (!bWriteSuccessed)
  359.             {
  360.               unzCloseCurrentFile(unzfile);
  361.               CloseHandle(hFile);
  362.               return false;
  363.             }
  364.           }
  365.         }
  367.         free(szReadBuffer);
  368.       }
  369.       unzGoToNextFile(unzfile);
  370.     }
  372.     delete pFileInfo;
  373.     delete pGlobalInfo;
  375.     if (unzfile)
  376.     {
  377.       unzClose(unzfile);
  378.     }
  380.     return true;
  381.   }
  382. };

如何使用类

压缩文件时可以通过调用zip.Compress()函数实现，该函数接受3个参数，第一个参数是需要压缩的目录名，第二个参数是压缩后保存的文件名，第三个参数则是压缩后主目录的名字，我们以压缩D:\\csdn目录下的所有文件为例，代码如下所示；

  1. int main(int argc, char* argv[])
  2. {
  3. 	MyZip zip;
  5. 	// 压缩目录
  6. 	std::string compress_src = "D:\\csdn";                               // 压缩目录
  7. 	std::string compress_dst = "D:\\test.zip";                           // 压缩后
  9. 	bool compress_flag = zip.Compress(compress_src, compress_dst, "lyshark");
  10. 	std::cout << "压缩状态: " << compress_flag << std::endl;
  12. 	system("pause");
  13. 	return 0;
  14. }

压缩后可以看到对应的压缩包内容，如下所示；

解压缩与压缩类似，通过调用zip.UnCompress实现，该方法需要传入两个参数，被压缩的文件名和解压到的目录名，如果目录不存在则会创建并解压。

  1. int main(int argc, char* argv[])
  2. {
  3. 	MyZip zip;
  5. 	// 解压缩目录
  6. 	std::string uncompress_src = "D:\\test.zip";                      // 被解压文件
  7. 	std::string uncompress_dst = "D:\\dst";                           // 解压到
  9. 	bool compress_flag = zip.UnCompress(uncompress_src, uncompress_dst);
  10. 	std::cout << "解压缩状态: " << compress_flag << std::endl;
  12. 	system("pause");
  13. 	return 0;
  14. }

输出效果如下所示；

原文链接：https://www.cnblogs.com/LyShark/p/17865137.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C++热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C++推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号