简易zlib库解压缩函数封装

最近由于要用zip解压缩，网上找了，没看到满意的源码，于是自己写了一个。亲测可用

 

接口很简单，看代码吧。有问题的地方欢迎留言指正

 

zlib_wrapper.h：

#ifndef ZLIB_WRAPPER
#define ZLIB_WRAPPER

#include <vector>
#include "zlib.h"

//把一个字节流用zip算法压缩，压缩结果存放在result_buffer里面
//src_buffer：    [IN]输入buffer的起始地址
//src_len:        [IN]输入buffer长度
//result_buffer:[OUT]存放压缩结果
//返回值：true-成功，buffer存放压缩结果
//         false-压缩失败
bool zip_buffer(const char *src_buffer, const unsigned int src_len, 
    std::vector<char> &result_buffer);

//从字节流中把数据解压出来
//src_buffer:        [in]待解压的buffer起始地址
//src_len:            [in]带解压buffer长度
//result_buffer:    [out]解压结果
//返回值：true-解压成功，buffer存放解压结果
//          false-解压失败
bool unzip_buffer(const char *src_buffer, const unsigned int src_len,
    std::vector<char> &result_buffer);


//辅助函数，用来得到解压缩的时候所使用的临时缓存的大小，这里我只是尽量取得一个合理的值.
//具体怎么获得可以修改
unsigned int get_temp_buffer_size(const unsigned int src_length);

#endif

 

zlib_wrapper.cpp:

#include "zlib_wrapper.h"

bool zip_buffer(const char *src_buffer, const unsigned int src_len, 
    std::vector<char> &result_buffer)
{
    if ((NULL == src_buffer) || (0 == src_len))
    {
        return false;
    }
    //得到要保存压缩结果的最小buffer大小
    unsigned long min_length = compressBound(src_len);
    result_buffer.resize(min_length);
    if (Z_OK != compress((Bytef*)&result_buffer[0], 
        &min_length, (Bytef*)src_buffer, src_len))
    {//压缩失败
        return false;
    }
    result_buffer.resize(min_length);

    return true;
}

unsigned int get_temp_buffer_size(const unsigned int src_length)
{
    const int MB = 1024*1024;
    if (src_length < 1*MB)
    {
        return 1*MB;
    }
    else if ((src_length >= 1*MB) && (src_length < 8*MB))
    {
        return 8*MB;
    }
    else
    {
        return 16*MB;
    }
}

bool unzip_buffer(const char *src_buffer, const unsigned int src_len, 
    std::vector<char> &result_buffer)
{
    if ((NULL == src_buffer) || (0 == src_len))
    {
        return false;
    }

    //提供临时缓存，保存解压的中间结果
    const unsigned int temp_buffer_size = get_temp_buffer_size(src_len);
    std::vector<char> temp_buffer(temp_buffer_size);
    //使用默认值
    z_stream zs;
    zs.zalloc = Z_NULL;
    zs.zfree = Z_NULL;
    zs.next_in = (Bytef*)src_buffer;
    zs.avail_in = src_len;
    zs.next_out = (Bytef*)&temp_buffer[0];
    zs.avail_out = temp_buffer_size;
    zs.opaque = NULL;
    if (Z_OK != inflateInit(&zs))
    {
        return false;
    }

    bool decompress_result = true;
    for (;;)
    {
        int ret_val = inflate(&zs, Z_SYNC_FLUSH);
        if ((Z_OK != ret_val) && (Z_STREAM_END != ret_val))
        {
            //发生错误
            decompress_result = false;
            break;
        }
        //得到缓存里面有效数据长度
        unsigned int valid_data_size = temp_buffer_size - zs.avail_out;
        result_buffer.insert(result_buffer.end(), 
            &temp_buffer[0], &temp_buffer[0]+valid_data_size);

        if (Z_OK == ret_val)
        {//待解压数据没有处理完
            //每次把输出缓冲区重置，免得每次都去计算输出缓冲区应该开始的地址
            zs.next_out = (Bytef*)&temp_buffer[0];
            zs.avail_out = temp_buffer_size;    
        }
        else if (Z_STREAM_END == ret_val)
        {//所有数据处理完成
            break;
        }
    }
    inflateEnd(&zs);

    return decompress_result;
}

 

转载请注明出处，谢谢！   http://www.cnblogs.com/chenkunyun/archive/2012/12/21/2828425.html