C/C++ Zlib库封装MyZip压缩类

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目录下的所有文件为例，代码如下所示；
[code]int main(int argc, char* argv[]){        MyZip zip;        // 压缩目录        std::string compress_src = "D:\\csdn";                               // 压缩目录        std::string compress_dst = "D:\\test.zip";                           // 压缩后        bool compress_flag = zip.Compress(compress_src, compress_dst, "lyshark");        std::cout