解压内存文件

最新推荐文章于 2024-11-06 08:13:21 发布
原创 最新推荐文章于 2024-11-06 08:13:21 发布 · 977 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个从内存中的zip文件解压缩的C++实现，通过定义zlib_filefunc_def结构体并自定义相关函数，配合unzOpen2使用，实现对内存中的zip文件进行解压，并将文件写入到指定目录。

当一段buffer为zip压缩内容时，如何解压缩呢，这里直接贴上代码

bool UnZipMemFile(MemFile* memfile, const std::wstring& dest_folder, zip_progress_callback cb_func, void* pVoid)
{
    zlib_filefunc_def zip_funcs;
    std::string strPathAnsi;
    int nRetCode;

    __int64 total_size = 0;
    DWORD dwResBuffer = 0;

    zip_funcs.zopen_file = ZipOpenFunc;
    zip_funcs.zread_file = ZipReadFunc;
    zip_funcs.zwrite_file = ZipWriteFunc;
    zip_funcs.ztell_file = ZipTellFunc;
    zip_funcs.zseek_file = ZipSeekFunc;
    zip_funcs.zclose_file = ZipCloseFunc;
    zip_funcs.zerror_file = ZipErrorFunc;
    zip_funcs.opaque=NULL;
    void* hZip = unzOpen2((const char*)memfile, &zip_funcs);
    if (NULL == hZip)
        return false;

    bool retval = false;
    std::wstring dest_root = dest_folder;
    FormatWinPath(dest_root);

    wchar_t ch = dest_folder[dest_folder.size() - 1];
    if (ch != L'\\')
        dest_root += L'\\';

    __int64 curpos = 0;
    std::string read_buffer;
    std::wstring last_path = dest_root;
    CreateDirectoryRecur(last_path);

    nRetCode = unzGoToFirstFile(hZip);
    while (UNZ_OK == nRetCode)
    {
        char szCurrentFile[260];
        unz_file_info fileInfo;
        uLong dwSeekPos;
        uLong dwSize;

        nRetCode = unzGetCurrentFileInfo(
            hZip,
            &fileInfo,
            szCurrentFile,
            sizeof(szCurrentFile),
            NULL,
            0,
            NULL,
            0
            );
        if (nRetCode != UNZ_OK)
            goto clean0;

        dwSeekPos = unzGetOffset(hZip);
        dwSize = fileInfo.uncompressed_size;

        if (dwSize > 0)
        {
            std::wstring tmp_path;
            std::wstring filename = dest_root + AnsiToUnicode(szCurrentFile, -1);
            FormatWinPath(filename);

            for (int i = filename.size() - 1; i > 0; i--)
            {
                if (filename[i] == L'\\')
                {
                    tmp_path = filename.substr(0, i);
                    break;
                }
            }

            if (tmp_path != last_path)
            {
                last_path = tmp_path;
                CreateDirectoryRecur(tmp_path);
            }

            nRetCode = unzOpenCurrentFile(hZip);
            if (nRetCode == UNZ_OK)
            {
                read_buffer.resize(dwSize + 4);
                nRetCode = unzReadCurrentFile(hZip, (void*)read_buffer.data(), dwSize);
                FILE* fp = _wfopen(filename.c_str(), L"wb");
                if (fp)
                {
                    fwrite(read_buffer.data(), 1, dwSize, fp);
                    fclose(fp);
                }               
                unzCloseCurrentFile(hZip);

                curpos += dwSize;
                if (cb_func)
                    cb_func(curpos, memfile->GetFileSize(), pVoid);
            }
        }

        nRetCode = unzGoToNextFile(hZip);
    }

    if (cb_func)
        cb_func(memfile->GetFileSize(), memfile->GetFileSize(), pVoid);

clean0:
    return retval;
}

 

 

其中的几个回调函数为：

    void* ZipOpenFunc(void* opaque, const char* filename, int mode)
    {
        return (void*)filename;
    }

    uLong ZipReadFunc(void* opaque, void* stream, void* buf, uLong size)
    {
        uLong ret = 0;
        MemFile* pMemFile = (MemFile*)stream;

        if (!pMemFile)
            goto clean0;

        pMemFile->ReadFile(buf, size, &ret);

clean0:
        return ret;
    }

    uLong ZipWriteFunc(void* opaque, void* stream, const void* buf, uLong size)
    {
        uLong ret = 0;
        MemFile* pMemFile = (MemFile*)stream;

        if (!pMemFile)
            goto clean0;

        pMemFile->WriteFile(buf, size, &ret);

clean0:
        return ret;
    }

    long ZipSeekFunc (void* opaque, void* stream, uLong offset, int origin)
    {
        uLong ret = -1;
        MemFile* pMemFile = (MemFile*)stream;
        DWORD dwRetCode;

        if (!pMemFile)
            goto clean0;

        dwRetCode = pMemFile->SetFilePointer(offset, NULL, origin);
        if (INVALID_SET_FILE_POINTER == dwRetCode)
            goto clean0;

        ret = 0;

clean0:
        return ret;
    }

    long ZipTellFunc(void* opaque, void* stream)
    {
        long ret=-1;
        MemFile* pMemFile = (MemFile*)stream;
        DWORD dwRetCode;

        if (!pMemFile)
            goto clean0;

        dwRetCode = pMemFile->SetFilePointer(0, NULL, FILE_CURRENT);
        if (INVALID_SET_FILE_POINTER == dwRetCode)
            goto clean0;

        ret = dwRetCode;

clean0:
        return ret;
    }

    int ZipCloseFunc(void* opaque, void* stream)
    {
        int ret=-1;
        MemFile* pMemFile = (MemFile*)stream;

        if (!pMemFile)
            goto clean0;

        if (!pMemFile->CloseHandle())
            goto clean0;

        ret = 0;

clean0:
        return ret;
    }

    int ZipErrorFunc(void* opaque, void* stream)
    {
        return 0;
    }

    void FormatFilePath(std::wstring & filepath)
    {
        int len = filepath.length();
        for(int i=0; i<len; i++)
        {
            if (filepath[i] == L'/')
                filepath[i] = L'\\';
        }
    }

 

其中用到了一个MemFile类，这个类的源代码网上很多，也很简单，也贴出代码吧：

    class AURORA_EXPORT MemFile
    {
    public:
        MemFile();
        MemFile(PVOID lpBuffer, DWORD dwLength);
        virtual ~MemFile();

        void SetData(PVOID lpBuffer, DWORD dwLength);
        BOOL ReadFile(LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead);

        BOOL WriteFile(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten);

        DWORD SetFilePointer(
            ULONG lDistanceToMove,
            PLONG lpDistanceToMoveHigh,
            DWORD dwMoveMethod
            );

        BOOL CloseHandle();
        __int64 GetFileSize();

    private:
        CAtlArray<BYTE> m_buffer;
        DWORD m_dwCurrentPos;
    };

    MemFile::MemFile()
    {
    }

    MemFile::MemFile(PVOID lpBuffer, DWORD dwLength)
        : m_dwCurrentPos(0)
    {
        m_buffer.SetCount(dwLength);
        memcpy(m_buffer.GetData(), lpBuffer, dwLength);
    }

    MemFile::~MemFile()
    {
    }

    void MemFile::SetData(PVOID lpBuffer, DWORD dwLength)
    {
        m_buffer.SetCount(dwLength);
        memcpy(m_buffer.GetData(), lpBuffer, dwLength);
    }

    __int64 MemFile::GetFileSize()
    {
        return m_buffer.GetCount();
    }

    BOOL MemFile::ReadFile(LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead)
    {
        BOOL retval = FALSE;
        DWORD dwReaded;

        if (!lpBuffer || !nNumberOfBytesToRead)
            goto clean0;

        if (m_dwCurrentPos + nNumberOfBytesToRead <= m_buffer.GetCount())
        {
            dwReaded = nNumberOfBytesToRead;
        }
        else
        {
            dwReaded = (DWORD)m_buffer.GetCount() - m_dwCurrentPos;
        }

        if (0 == dwReaded)
            goto clean0;

        memcpy(lpBuffer, m_buffer.GetData() + m_dwCurrentPos, dwReaded);
        m_dwCurrentPos += dwReaded;

        if (lpNumberOfBytesRead)
            *lpNumberOfBytesRead = dwReaded;

        retval = TRUE;

clean0:
        return retval;
    }

    BOOL MemFile::WriteFile(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten)
    {
        BOOL retval = FALSE;
        DWORD dwWritten = nNumberOfBytesToWrite;

        if (!lpBuffer || !nNumberOfBytesToWrite)
            goto clean0;

        if (m_dwCurrentPos + nNumberOfBytesToWrite > m_buffer.GetCount())
        {
            m_buffer.SetCount(m_dwCurrentPos + nNumberOfBytesToWrite);
        }

        memcpy(m_buffer.GetData() + m_dwCurrentPos, lpBuffer, dwWritten);
        m_dwCurrentPos += dwWritten;

        if (lpNumberOfBytesWritten)
            *lpNumberOfBytesWritten = dwWritten;

        retval = TRUE;

clean0:
        return retval;
    }

    DWORD MemFile::SetFilePointer(
        ULONG lDistanceToMove,
        PLONG lpDistanceToMoveHigh,
        DWORD dwMoveMethod
        )
    {
        DWORD retval = INVALID_SET_FILE_POINTER;

        if (FILE_CURRENT == dwMoveMethod)
        {
            if (lDistanceToMove > 0)
            {
                if (m_dwCurrentPos + lDistanceToMove < m_buffer.GetCount())
                {
                    m_dwCurrentPos += lDistanceToMove;
                }
                else
                {
                    goto clean0;
                }
            }
            else
            {
                if (m_dwCurrentPos >= lDistanceToMove)
                {
                    m_dwCurrentPos += lDistanceToMove;
                }
                else
                {
                    goto clean0;
                }
            }
        }
        else if (FILE_END == dwMoveMethod)
        {
            if (lDistanceToMove > 0)
                goto clean0;

            if (m_buffer.GetCount() + lDistanceToMove < 0)
                goto clean0;

            m_dwCurrentPos = (DWORD)m_buffer.GetCount() + lDistanceToMove;
        }
        else if (FILE_BEGIN == dwMoveMethod)
        {
            if (lDistanceToMove < 0)
                goto clean0;

            if (lDistanceToMove >= m_buffer.GetCount())
                goto clean0;

            m_dwCurrentPos = lDistanceToMove;
        }

clean0:
        return m_dwCurrentPos;
    }

    BOOL MemFile::CloseHandle()
    {
        return TRUE;
    }

 

 

C++ 解压文件及文件夹 使用zlib开源库
我不是码农的博客~~~
05-13 2227
C++ 解压文件及文件夹 使用zlib开源库 使用zlib-1.2.11版本的开源库，实现我需要的对文件或者文件夹的解压，查阅了一些博客大牛的资料，后面根据自己的需要修改。这是续上一篇的压缩，好久了都忘记这回事了。下面给出我的代码： #include "stdafx.h" #include <string> #include <iostream> #include <vector> #include <Shlwapi.h> #include "zip.h"
ABB机器人与上位机进行Socket通信的RAPID代码实现（服务端）
热门推荐
凡是过往，皆为序章
07-30 1万+
文章目录前言1.实现的功能2.建立Socket通信2.1 ABB机器人的IP地址：2.2 SocketAccept的说明3.服务端接发信息3.1 核心代码3.2 CurrentPos函数4.完整代码5.实现效果 前言 本文采取TCP/IP中Socket的方式实现ABB与上位机的通信。其中上位机做为客户端，机器人作为服务端，此方法可以为ABB机器人的二次开发的网络通信部分提供一点参考。 1.实现的功能 上位机先给机器人发送字符串，机器人收到后开始向第一个目标点移动，当到达目标位置后，机器人自动给上位机返回一个
压缩解压库，内存中解压
银河系卧底
02-15 379
/// This is a helper function... template _RandomAccessIterator __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __pivot) { while
在内存中压缩及解压缩
qianlima210210的专栏
04-20 2611
在内存中压缩及解压缩
java 纯内存解压zip文件
10-11
java 纯内存解压zip文件，没有磁盘操作，效率高，基于apache commons-compress实现
Wc3Dump (MQP解压内存提取工具)
06-14
Wc3Dump (War3文件内存提取工具) 制作:RahXephon 功能和使用:首先运行config配置解压路径和解压文件,保存配置后运行WAR3,再使用Wc3DumpLoader启动程序,WAR3.exe会提示启动成功.之后只要正常的进行游戏就可以了,当游戏结束后在制定文件夹内可以找到需要的解压文件(注意这里的文件是最后运行的地图的文件,对于在MPQ中的同名文件也会被解压) 注意:建议使用窗口模式运行WAR3后使用本程序,使用解压时进行提示功能会在解压文件前弹出对话框提示当前正在解压的文件名,但是此功能在全屏模式下可能会出问题.
zipOpen2_64 unzOpen2_64 return NULL
Drecik__的专栏
12-21 3663
也是醉了，zlib在Windows下的坑实在太多了，这已经是第三个了，还没在Linux下测试，不知道Linux下还有没有坑。。照着minizip和miniunz封装了两个类，发现在压缩使用APPEN属性的时候zipOpen2_64 return NULL，以及在unzOpen2_64任何情况下都return NULL，刚开始以为自己代码写错了，结果发现直接启动官方程序也是这样。。调试发现Window
Zip内存解压 静态编译不带dll文件 支持密码解压
03-14
本项目针对ZIP文件的处理，特别是内存解压、静态编译以及密码解压功能进行了实现，使得开发者能够在不依赖外部DLL文件的情况下，轻松地在C++环境下对ZIP文件进行操作。 首先，"内存解压"是指在程序运行过程中，将...
unity4.3从文件压缩到内存再从内存解压到文件 Assetbundle　源码
11-06
标题"unity4.3从文件压缩到内存再从内存解压到文件 Assetbundle 源码"提及的是在Unity4.3版本中，如何实现AssetBundle的压缩与解压缩过程，这个过程涉及到文件I/O操作以及数据压缩和解压缩的算法。在Unity中，通常...
易语言模块文件压缩解压.rar
03-29
在“易语言模块文件压缩解压.rar”这个压缩包中，包含的资源很可能是用于处理易语言程序中文件压缩和解压功能的模块。下面将详细介绍这个主题中的相关知识点。 一、易语言模块 易语言模块是易语言编程中的一个重要...
完美解决java读取大文件内存溢出的问题
08-29
完美解决java读取大文件内存溢出的问题 在Java中读取大文件时，内存溢出是一个常见的问题。传统方式的读取文件方式会将整个文件读取到内存中，导致程序抛出OutOfMemoryError异常。但是，我们可以通过行迭代方式来...
[Zlib]_[初级]_[使用zlib库解压提取文件]
小白
03-28 1万+
场景： 1. zlib库跨平台，Windows和MacOSX都可以使用，还支持64位编译，轻量级，没有不用的道理。 2. 处理.zip,apk,docx文件时，因为这类文件都是zip格式，使用zlib能方便提取压缩文件里的数据。
网易博客旧文----实现zip格式的内存压缩
XZHOUMIN的博客
11-06 428
minizip（http://www.winimage.com/zLibDll/minizip.html）只是实现了文件的压缩解压缩，有时我们需要直接对内存的数据进行zip格式的压缩解压缩，本文对此进行了研究。由于zlib是一个要使用于多个平台的库，因此对于IO的操作就是用回调函数的方式来实现的，在不同的平台上使用不同的文件操作函数就可以实现跨平台。因此对内存的压缩解压缩就是基于此，单独写一些内存操作的函数，模拟文件读写等操作，压缩解压缩最终操作的就是内存，因此就达到了我们的目的。
报错：Registered callback does not match with the provided url
weixin_42393724的博客
06-01 96
解决报错Registered callback does not match with the provided url.
zlib压缩和解压的使用
化石
09-11 9972
1、unzOpen(filePath) 这个方法可以打开一个压缩文件，返回一个句柄，这个句柄将在后面的方法中被用到。 2、unzGetGlobalInfo() 这个可以得到全局的信息。常用的是压缩包里的文件个数。 3、unzGotoFirstFile() 定位到压缩文件中的第一个文件。     3.1 unzGetCurrentFileI
利用ABB机器人的CRobT写一个判断机器人是否移动至目标位置的函数
凡是过往，皆为序章
07-30 1万+
文章目录前言RAPID位置函数CRobT的说明判断是否达到目标位置的代码实现 前言 在使用ABB机器人做二次开发时，可能会需要根据机器人目前的位置来判断是否需要进行下一步的指令执行，ABB机器人提供了获取机器人实时位置状态的函数，查阅ABB官方的手册可以找到。我再根据此函数写了判断机器人是否到达目标位置的功能，仅供参考。 RAPID位置函数 这里选取CRobT这个函数来实现需要的功能。 CRobT的说明 没有特殊情况的话，选取它的两个主元[\Tool][\WObj]初始化就行，即 CRobT(\Too
以金山界面库（openkui）为例思考和分析界面库的设计和实现——资源读取模块分析...
20386053
03-12 315
按照软件的执行流程，我们首先遇到《以金山界面库（openkui）为例思考和分析界面库的设计和实现——问题》中提出的最后一个问题：界面描述文件的放置位置。我们曾提出一种方案：将界面描述文件打包后放在资源文件中；在使用时，解析并读取资源文件。实际上Kui也是按照我们这个思路在做的，只是做得比我们要精巧。在阅读这部分代码的过程中，我发现其存在一定的编码缺陷以及设计缺陷。我会在文中适时指出问题并提...
C++ zip压缩库使用
MusicMan
11-22 9618
这个压缩库，主要是用来解压和压缩相关文件使用，好处就是引入比较方便，而且极其易使用，方便用户操作。 首先是引入这四个文件，相关代码如下： 首先是zip.h头文件 #ifndef _zip_H #define _zip_H // ZIP functions -- for creating zip files // This file is a repackaged form of the I...
文件解压时显示内存不够
最新发布
07-16
在解压文件时遇到“内存不足”的错误，通常是由于系统或解压工具在处理大文件时无法分配足够的内存资源导致的。以下是几种可能的解决方案： ### 1. **关闭不必要的程序** 系统内存不足时，首先尝试关闭其他占用内存...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值