簡易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