Zlib 数据压缩库详解与应用入门

引言

在数字世界中，数据无处不在。随着数据量的爆炸式增长，如何高效地存储、传输和处理数据成为了一个关键挑战。数据压缩技术应运而生，它通过去除数据中的冗余信息，减小数据体积，从而节省存储空间、降低传输带宽需求并提升处理速度。在众多数据压缩库中，zlib 无疑是最著名、使用最广泛的开源库之一。从互联网传输（HTTP/1.1 的 GZIP 编码）、文件归档（ZIP、GZIP、PNG 图片格式内部）到操作系统内核、嵌入式系统，zlib 的身影几乎无处不在。

本文将深入探讨 zlib 库的内部原理、核心 API，并通过具体的代码示例带你入门 zlib 的应用。

第一部分：数据压缩基础与 DEFLATE 算法

在深入 zlib 之前，理解一些基本的数据压缩概念是必要的。

无损压缩 vs. 有损压缩：
- 无损压缩 (Lossless Compression): 解压后的数据与原始数据完全一致，没有任何信息丢失。适用于文本文件、程序代码、重要文档以及部分图片格式（如 PNG、GIF）等对数据完整性要求极高的场景。zlib 属于无损压缩库。
- 有损压缩 (Lossy Compression): 解压后的数据与原始数据不完全相同，但这种差异通常对人类感知影响较小（如图片、音频、视频）。适用于对数据保真度要求相对较低、但追求更高压缩率的场景（如 JPEG 图片、MP3 音频、MP4 视频）。
常见的无损压缩技术：
- 行程长度编码 (Run-Length Encoding, RLE): 简单地用 (重复次数, 重复数据) 的形式来表示连续重复的数据。例如，”AAAAABBC” 可以编码为 “(5, A), (2, B), (1, C)”。适用于有大量连续相同数据的场景。
- 字典编码 (Dictionary Coding): 在数据中查找重复出现的字节序列，并用一个较短的“码字”或“引用”来代替这些序列。LZ77、LZ78、LZW 是典型的字典编码算法。LZ77 特别重要，它是 DEFLATE 算法的基础之一。它通过查找当前数据之前已出现过的匹配序列（称为“回溯引用”），并用 (长度, 距离) 对来表示。例如，”ABCABC” 可以编码为 “ABC” 后跟一个引用：从当前位置回溯 3 个字节，长度为 3。
- 熵编码 (Entropy Coding): 基于数据中符号出现的概率，为出现频率高的符号分配较短的编码，为出现频率低的符号分配较长的编码，从而达到压缩目的。Huffman 编码和算术编码是常见的熵编码算法。
DEFLATE 算法：zlib 的核心
zlib 使用的核心算法是 DEFLATE。DEFLATE 是一种无损数据压缩算法，它结合了 LZ77 算法的一个变种 和 Huffman 编码。
- LZ77 部分： DEFLATE 使用滑动窗口技术（默认窗口大小为 32KB）。它在当前要编码的数据前的滑动窗口中查找最长匹配的字节序列。如果找到匹配，就输出一个 (长度, 距离) 对。距离 指的是匹配序列开始位置距离当前位置有多远（回溯距离），长度 指的是匹配序列的长度。如果找不到匹配，或者找到的匹配不够长（通常小于 3个字节），则直接输出原始的字节数据（称为“字面值”，Literal）。
- Huffman 编码部分： DEFLATE 对 LZ77 阶段产生的输出进行二次压缩。这些输出包括两种类型的数据：
  - 字面值 (Literals): 没有找到合适匹配的单个字节。
  - 长度-距离对 (Length-Distance Pairs): LZ77 找到的匹配序列的表示。
    DEFLATE 会构建两组 Huffman 编码表：一个用于字面值和长度，另一个用于距离。通过对这些字面值、长度和距离值应用 Huffman 编码，进一步压缩数据。DEFLATE 可以选择使用预定义的静态 Huffman 表或根据当前数据动态生成 Huffman 表。动态表通常能提供更好的压缩率，但需要在压缩流中包含表本身的数据。

DEFLATE 算法的巧妙结合使得它在压缩率和压缩/解压速度之间取得了很好的平衡，这也是 zlib 如此流行的原因之一。DEFLATE 算法本身被定义在 RFC 1951 中。

第二部分：Zlib 库的特性与设计理念

zlib 库 (由 Jean-loup Gailly 和 Mark Adler 开发) 是 DEFLATE 算法的一个开源、跨平台的实现。它具有以下主要特性和设计理念：

免费和开源： zlib 使用 zlib 许可协议，这是一个非常宽松的开源许可，允许在任何项目（包括商业项目）中自由使用、分发和修改，无需支付任何费用或担心专利问题。
高度可移植性： zlib 完全由 C 语言编写，并且避免使用平台相关的特性。它可以在几乎所有主流操作系统和硬件平台上编译和运行，包括 Windows、Linux、macOS、BSD 以及各种嵌入式系统。
高效： zlib 的 DEFLATE 实现经过高度优化，提供了良好的压缩速度和解压速度。解压通常比压缩快得多。
流式处理能力： zlib 的 API 设计允许用户分块地处理数据，非常适合处理大文件或网络数据流，而无需一次性将整个数据加载到内存中。这通过维护一个内部状态机来实现。
内存管理： zlib 提供了自定义内存分配和释放函数的接口（zalloc 和 zfree），这对于在内存受限的环境中使用 zlib 非常有用。
数据完整性检查： zlib 提供了 Adler-32 和 CRC-32 两种校验和计算功能，用于验证数据在传输或存储过程中是否发生损坏。
多种输出格式支持： zlib 库不仅实现了纯粹的 DEFLATE 流（RFC 1951），还支持带有简单头部和尾部的 zlib 格式（RFC 1950）以及标准的 gzip 格式（RFC 1952）。gzip 格式在 zlib 格式的基础上增加了更多信息，如原始文件名、时间戳等，常用于文件压缩。

第三部分：Zlib 核心 API 详解

zlib 的 API 主要围绕 z_stream 结构体展开，该结构体包含了压缩或解压缩操作所需的所有状态信息、输入/输出缓冲区指针和大小等。

核心结构体：z_stream

“`c
typedef struct z_stream_s {
const Bytef *next_in; // 指向下一个待压缩/解压缩的输入字节
uInt avail_in; // next_in 指向的缓冲区中还有多少字节可用

Bytef    *next_out;    // 指向下一个输出字节应该存放的位置
uInt     avail_out;    // next_out 指向的缓冲区中还有多少空间可用

uLong    total_in;   // 到目前为止输入的总字节数
uLong    total_out;  // 到目前为止输出的总字节数

char     *msg;       // 最后一次操作的错误信息，如果 non Z_OK

struct internal_state FAR *state; // 内部状态结构体，用户不应直接访问

z_alloc_func zalloc; // 用户自定义的内存分配函数 (默认为 malloc)
z_free_func  zfree;  // 用户自定义的内存释放函数 (默认为 free)
void FAR     *opaque;  // 传递给 zalloc/zfree 的不透明指针

int      data_type;    // 压缩时用于提示数据类型 (文本或二进制)
uLong    adler;      // 校验和值 (Adler-32 或 CRC-32)
uLong    reserved;   // 保留字段

} z_stream;
“`

理解 next_in, avail_in, next_out, avail_out 是使用 zlib 的关键。在每次调用压缩/解压缩函数时：
* next_in 指向输入数据的当前位置。
* avail_in 是从 next_in 开始还有多少输入数据可供处理。函数会消耗一部分或全部 avail_in 字节。
* next_out 指向输出缓冲区的当前写入位置。
* avail_out 是从 next_out 开始输出缓冲区还有多少空间可用。函数会写入一部分或全部到这个空间。
* 函数返回后，next_in 会被更新指向未处理的输入数据的起始位置，avail_in 会减小已处理的字节数。
* next_out 会被更新指向已写入的输出数据的末尾位置+1，avail_out 会减小已写入的字节数。
* total_in 和 total_out 分别累加总的输入和输出字节数。

压缩函数：deflateInit, deflate, deflateEnd

int deflateInit(z_stream *strm, int level);
- 初始化一个用于压缩的 z_stream 结构体。
- strm: 指向待初始化的 z_stream 结构体。
- level: 压缩级别，范围通常是 Z_NO_COMPRESSION (0) 到 Z_BEST_COMPRESSION (9)。Z_DEFAULT_COMPRESSION (-1) 通常介于 6-8 之间，提供了不错的平衡。级别越高，压缩率通常越高，但耗时越长。
- 返回 Z_OK 表示成功，否则返回错误码。
- deflateInit 会为 strm->state 分配内存。
int deflateInit2(z_stream *strm, int level, int method, int windowBits, int memLevel, int strategy);
- 更灵活的初始化函数。
- method: 压缩方法，目前只支持 Z_DEFLATED。
- windowBits: 控制 LZ77 滑动窗口大小和输出格式。
  - 9 到 15: 使用 LZ77 窗口大小 2^(windowBits) 字节。输出 zlib 头部和尾部 (RFC 1950)。
  - -9 到 -15: 使用 LZ77 窗口大小 2^(-windowBits) 字节。输出原始 DEFLATE 流 (RFC 1951)，没有头部和尾部。
  - 25 到 31: 等同于 windowBits 减去 16 (即 9 到 15)，但输出 gzip 头部和尾部 (RFC 1952)。
- memLevel: 控制压缩器内部内存的使用量，范围 1 到 9。级别越高，使用内存越多，但可能提升压缩率。
- strategy: 压缩策略，用于调整压缩算法以适应不同类型的数据。常用值包括 Z_DEFAULT_STRATEGY, Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED。大多数情况下使用 Z_DEFAULT_STRATEGY 即可。
- 返回 Z_OK 表示成功，否则返回错误码。
int deflate(z_stream *strm, int flush);
- 执行实际的压缩操作。这是核心函数，通常在一个循环中调用。
- strm: 指向已初始化的 z_stream 结构体。输入数据在 strm->next_in/avail_in 中，输出缓冲区在 strm->next_out/avail_out 中。
- flush: 控制如何处理剩余的输入数据和内部缓冲区。
  - Z_NO_FLUSH: 默认值。允许 deflate 在内部缓冲数据以获得更好的压缩率。函数可能不会消耗所有 avail_in 或填充所有 avail_out。
  - Z_SYNC_FLUSH: 强制 deflate 输出所有当前可压缩的数据，并对齐到字节边界。用于需要在流中间点刷新输出（例如网络协议中）的场景。会降低压缩效率。
  - Z_FULL_FLUSH: 比 Z_SYNC_FLUSH 更进一步，还会重置压缩状态，不允许前面对流中数据的引用。用于恢复压缩流的同步，但不推荐频繁使用，会严重影响压缩率。
  - Z_FINISH: 通知 deflate 这是输入的最后一块数据。deflate 会处理完所有剩余输入，输出所有挂起的数据，并添加必要的流结束标记。调用 deflate 时使用 Z_FINISH，直到返回 Z_STREAM_END 为止。
- 返回 Z_OK (操作正常进行)、Z_STREAM_END (处理完所有数据并输出流结束标记)、Z_BUF_ERROR (没有足够的 avail_out 空间来输出所有挂起的数据，需要提供更多空间后再次调用 deflate)、或其他错误码。
int deflateEnd(z_stream *strm);
- 清理压缩器状态，释放 deflateInit (或 deflateInit2) 分配的内存。
- 在使用完 z_stream 后必须调用此函数。
- 返回 Z_OK 表示成功，否则返回错误码。

解压缩函数：inflateInit, inflate, inflateEnd

int inflateInit(z_stream *strm);
- 初始化一个用于解压缩的 z_stream 结构体。
- strm: 指向待初始化的 z_stream 结构体。
- 返回 Z_OK 表示成功，否则返回错误码。
- inflateInit 会为 strm->state 分配内存。
int inflateInit2(z_stream *strm, int windowBits);
- 更灵活的解压缩初始化函数。
- windowBits: 控制解压缩器期望的输入流格式和 LZ77 窗口大小。这是解压缩成功的关键参数！
  - 9 到 15: 期望 zlib 头部和尾部 (RFC 1950)，LZ77 窗口大小 2^(windowBits) 字节。
  - -9 到 -15: 期望原始 DEFLATE 流 (RFC 1951)，没有头部和尾部。LZ77 窗口大小 2^(-windowBits) 字节。
  - 25 到 31: 等同于 windowBits 减去 16 (即 9 到 15)，期望 gzip 头部和尾部 (RFC 1952)。
  - 32 + windowBits (例如 47 = 32 + 15): 期望 zlib 或 gzip 头部，自动检测。如果检测到 gzip 头部，则处理 gzip 尾部（包括 CRC32 校验和和原始大小）。如果检测到 zlib 头部，则处理 zlib 尾部（Adler32 校验和）。这是处理未知 zlib/gzip 流时常用的设置。
- 返回 Z_OK 表示成功，否则返回错误码。
int inflate(z_stream *strm, int flush);
- 执行实际的解压缩操作。核心函数，通常在一个循环中调用。
- strm: 指向已初始化的 z_stream 结构体。输入数据在 strm->next_in/avail_in 中，输出缓冲区在 strm->next_out/avail_out 中。
- flush: 控制解压缩的行为。对于解压缩，Z_NO_FLUSH 和 Z_SYNC_FLUSH 是最常用的。
  - Z_NO_FLUSH: 默认值。解压缩器会尽可能多地消耗输入并产生输出。
  - Z_SYNC_FLUSH: 如果有足够的输入，则解压缩到下一个同步点。用于在流中间恢复。
  - Z_FINISH: 告诉解压缩器输入已结束。
- 返回 Z_OK (操作正常进行)、Z_STREAM_END (成功到达流的末尾并处理完所有数据)、Z_BUF_ERROR (没有足够的 avail_out 空间来存放解压缩的数据)、Z_DATA_ERROR (输入数据损坏)、Z_STREAM_ERROR (状态不一致) 或其他错误码。解压缩通常需要持续调用 inflate 直到返回 Z_STREAM_END。
int inflateEnd(z_stream *strm);
- 清理解压缩器状态，释放 inflateInit (或 inflateInit2) 分配的内存。
- 在使用完 z_stream 后必须调用此函数。
- 返回 Z_OK 表示成功，否则返回错误码。

校验和函数：adler32, crc32

uLong adler32(uLong adler, const Bytef *buf, uInt len);
- 计算 Adler-32 校验和。Adler-32 比 CRC-32 计算速度更快，但在检测某些类型的错误时可能稍弱。
- adler: 前一次计算的校验和值，第一次调用时通常传入 adler32(0L, Z_NULL, 0) 得到的初始值。
- buf: 数据缓冲区。
- len: 缓冲区长度。
- 返回计算出的校验和。
uLong crc32(uLong crc, const Bytef *buf, uInt len);
- 计算 CRC-32 校验和。CRC-32 在检测数据损坏方面比 Adler-32 更可靠，但计算速度稍慢。
- crc: 前一次计算的校验和值，第一次调用时通常传入 crc32(0L, Z_NULL, 0) 得到的初始值。
- buf: 数据缓冲区。
- len: 缓冲区长度。
- 返回计算出的校验和。

第四部分：Zlib 应用入门示例 (C语言)

下面的 C 代码示例演示了如何使用 zlib 库压缩和解压缩内存中的一个数据块。为了简化，这个例子没有处理分块/流式输入输出，而是假设所有输入都在一个缓冲区中，输出也在一个缓冲区中。实际应用中处理大文件或流时需要循环调用 deflate 和 inflate。

“`c

include

// 错误处理宏
#define CHECK_ERR(err, msg) { \
if (err < 0) { \
fprintf(stderr, “%s error: %d\n”, msg, err); \
exit(1); \
} \
}

// 压缩函数
// 输入: source (原始数据), sourceLen (原始数据长度)
// 输出: dest (压缩后的数据缓冲区), destLen (压缩后的数据长度)
// 返回值: Z_OK 成功, 其他为错误码
int compress_buffer(Bytef source, uLong sourceLen, Bytef dest, uLong destLen) {
int ret;
z_stream strm;
uLong compressed_buffer_size = compressBound(sourceLen); // 估算压缩后最大可能的大小
dest = (Bytef )malloc(compressed_buffer_size);
if (*dest == NULL) {
return Z_MEM_ERROR;
}

// 初始化 z_stream 结构体
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;

// 初始化压缩器，使用默认设置 (Z_DEFAULT_COMPRESSION, windowBits=15, etc.)
// Z_DEFAULT_COMPRESSION (-1) 通常是 level 6-8
ret = deflateInit(&strm, Z_DEFAULT_COMPRESSION);
if (ret != Z_OK) {
    free(*dest);
    *dest = NULL;
    return ret;
}

// 设置输入和输出缓冲区
strm.next_in = source;
strm.avail_in = sourceLen;
strm.next_out = *dest;
strm.avail_out = compressed_buffer_size; // 假定一次性压缩到足够大的缓冲区

// 执行压缩
// Z_FINISH 表示这是最后一块输入，需要输出所有数据并结束流
ret = deflate(&strm, Z_FINISH);
if (ret != Z_STREAM_END) { // 对于单块数据，期望返回 Z_STREAM_END
    deflateEnd(&strm);
    free(*dest);
    *dest = NULL;
    if (ret == Z_OK || ret == Z_BUF_ERROR) {
         // 如果是 Z_OK 或 Z_BUF_ERROR，说明 avail_out 不足，但本示例使用了 compressBound 应该足够
         // 如果数据极端难以压缩，compressBound 可能估计不足。实际流式处理需要循环和动态扩容
         fprintf(stderr, "Compression error: did not reach Z_STREAM_END (%d)\n", ret);
         return Z_BUF_ERROR; // 假定是缓冲区不足
    }
    return ret;
}

// 压缩成功，计算实际输出的数据长度
*destLen = strm.total_out;

// 清理压缩器状态
deflateEnd(&strm);

return Z_OK;

}

// 解压缩函数
// 输入: source (压缩数据), sourceLen (压缩数据长度)
// 输出: dest (解压缩后的数据缓冲区), destLen (解压缩后的数据长度)
// 返回值: Z_OK 成功, 其他为错误码
int decompress_buffer(Bytef source, uLong sourceLen, Bytef dest, uLong destLen) {
int ret;
z_stream strm;
uLong decompressed_buffer_size = sourceLen * 5; // 初始估算解压后的大小 (通常会比原始大，5倍是一个保守的开始)
*dest = NULL; // 初始为空，可能需要循环中重新分配

// 初始化 z_stream 结构体
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = 0;
strm.next_in = Z_NULL;

// 初始化解压缩器
// inflateInit 使用默认设置，期望 zlib 头部 (windowBits=15)
ret = inflateInit(&strm);
if (ret != Z_OK) {
    return ret;
}

// --- 实际解压缩过程，需要循环处理 ---
strm.next_in = source;
strm.avail_in = sourceLen;

// 分配初始输出缓冲区
*dest = (Bytef *)malloc(decompressed_buffer_size);
if (*dest == NULL) {
    inflateEnd(&strm);
    return Z_MEM_ERROR;
}
strm.next_out = *dest;
strm.avail_out = decompressed_buffer_size;

// 循环解压缩，直到输入耗尽或流结束
do {
    // 如果输出缓冲区满了，需要重新分配更大的缓冲区
    if (strm.avail_out == 0) {
        uLong old_size = decompressed_buffer_size;
        decompressed_buffer_size *= 2; // 扩大两倍
        Bytef *temp_dest = (Bytef *)realloc(*dest, decompressed_buffer_size);
        if (temp_dest == NULL) {
            inflateEnd(&strm);
            free(*dest);
            *dest = NULL;
            return Z_MEM_ERROR;
        }
        *dest = temp_dest;
        // 更新 next_out 和 avail_out，注意 next_out 需要指向新缓冲区的末尾
        strm.next_out = *dest + old_size;
        strm.avail_out = decompressed_buffer_size - old_size;
    }

    // 执行解压缩
    ret = inflate(&strm, Z_NO_FLUSH); // 通常使用 Z_NO_FLUSH
    if (ret != Z_OK && ret != Z_STREAM_END && ret != Z_BUF_ERROR) {
        // 遇到了数据错误或其他不可恢复的错误
        inflateEnd(&strm);
        free(*dest);
        *dest = NULL;
        return ret;
    }

} while (ret != Z_STREAM_END && strm.avail_in > 0); // 循环直到流结束或输入耗尽

// 检查是否成功到达流的末尾
if (ret != Z_STREAM_END) {
    // 如果输入数据提前耗尽但未达到流末尾标记，可能是输入不完整
    inflateEnd(&strm);
    free(*dest);
    *dest = NULL;
    fprintf(stderr, "Decompression error: incomplete stream\n");
    return Z_DATA_ERROR; // 或者 Z_BUF_ERROR 看具体情况
}

// 解压缩成功，计算实际输出的数据长度
*destLen = strm.total_out;

// 清理解压缩器状态
inflateEnd(&strm);

// 调整缓冲区大小到实际数据长度 (可选，节省内存)
if (*destLen < decompressed_buffer_size) {
    Bytef *temp_dest = (Bytef *)realloc(*dest, *destLen);
    if (temp_dest != NULL) {
        *dest = temp_dest;
    }
    // 如果realloc失败，不影响功能，只是没能节省内存
}


return Z_OK;

}

int main() {
const char *original_data = “This is a sample string to test zlib compression and decompression. ”
“It contains some repeated words like ‘test’ and ‘compression’. ”
“Let’s make it a bit longer to see the effect of compression. ”
“aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa”
“bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb”
“ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc”
“This is a sample string to test zlib compression and decompression again. ”
“More data means more potential for compression.”;
uLong original_len = strlen(original_data) + 1; // +1 for null terminator

Bytef *compressed_data = NULL;
uLong compressed_len = 0;
Bytef *decompressed_data = NULL;
uLong decompressed_len = 0;

printf("Original data length: %lu bytes\n", original_len);

// --- 压缩 ---
int ret = compress_buffer((Bytef *)original_data, original_len, &compressed_data, &compressed_len);
CHECK_ERR(ret, "Compression failed");

printf("Compressed data length: %lu bytes\n", compressed_len);
if (compressed_data) {
     printf("Compression ratio: %.2f%%\n", (double)compressed_len / original_len * 100.0);
}


// --- 解压缩 ---
ret = decompress_buffer(compressed_data, compressed_len, &decompressed_data, &decompressed_len);
CHECK_ERR(ret, "Decompression failed");

printf("Decompressed data length: %lu bytes\n", decompressed_len);

// --- 验证 ---
if (decompressed_len == original_len && memcmp(original_data, decompressed_data, original_len) == 0) {
    printf("Verification successful: decompressed data matches original.\n");
} else {
    fprintf(stderr, "Verification failed: decompressed data does NOT match original.\n");
    fprintf(stderr, "Decompressed data: %s\n", decompressed_data);
}

// --- 清理 ---
free(compressed_data);
free(decompressed_data);

return 0;

}
“`

代码解析：

包含头文件: #include <zlib.h> 引入 zlib 库的函数和类型定义。
compress_buffer 函数:
- 使用 compressBound(sourceLen) 估算压缩后最大可能的长度，用于分配初始输出缓冲区。这个函数保证对于任何输入，压缩后的数据不会超过这个大小，方便一次性分配。
- 初始化 z_stream，设置 zalloc, zfree, opaque 为 Z_NULL 使用默认的 malloc/free。
- 调用 deflateInit 初始化压缩器，这里使用默认压缩级别 Z_DEFAULT_COMPRESSION。
- 设置 strm->next_in, strm->avail_in 为输入数据和其长度。
- 设置 strm->next_out, strm->avail_out 为输出缓冲区和其大小。
- 调用 deflate(&strm, Z_FINISH)。Z_FINISH 标志告诉 zlib 这是最后一块输入，需要完成压缩过程并输出流结束标记。因为我们假设所有输入都在一个缓冲区里一次处理，所以只需要一次调用 deflate 并传入 Z_FINISH。对于流式处理，你需要在一个循环中调用 deflate(&strm, Z_NO_FLUSH)，直到 strm->avail_in 为 0，然后再用 Z_FINISH 标志调用 deflate 直到返回 Z_STREAM_END。
- 检查返回值是否为 Z_STREAM_END，这是成功结束的标志。
- strm.total_out 记录了实际输出的总字节数。
- 最后调用 deflateEnd(&strm) 清理资源。
decompress_buffer 函数:
- 对解压缩后的大小进行初始估算（例如输入大小的几倍），并分配缓冲区。重要： 解压缩后的数据通常会比压缩前大，而且具体大多少无法精确预知，尤其对于短小或随机的数据，压缩可能会“膨胀”。因此，实际应用中解压缩通常需要在一个循环中进行，并在输出缓冲区不足时动态扩容。本示例演示了这个动态扩容的过程。
- 初始化 z_stream。
- 调用 inflateInit 初始化解压缩器。默认情况下 inflateInit 期望输入流带有 zlib 头部。如果你压缩时使用了 -windowBits 参数生成了原始 DEFLATE 流，或者使用了 windowBits >= 32 生成了 gzip 流，这里就需要使用 inflateInit2 并传入对应的 windowBits 值来匹配。
- 设置 strm->next_in, strm->avail_in 为压缩数据和其长度。
- 设置 strm->next_out, strm->avail_out 为输出缓冲区和其大小。
- 进入一个 do...while 循环。在循环中：
  - 检查 strm->avail_out 是否为 0。如果是，说明当前输出缓冲区已满，需要使用 realloc 扩大缓冲区。注意 realloc 可能返回 NULL，需要检查。同时要正确更新 strm->next_out 和 strm->avail_out 到新缓冲区中未使用的部分。
  - 调用 inflate(&strm, Z_NO_FLUSH) 执行解压缩。通常在解压缩时使用 Z_NO_FLUSH。
  - 检查 inflate 的返回值。Z_OK 表示正常进行；Z_STREAM_END 表示解压完成；其他负值表示错误（如 Z_DATA_ERROR 数据损坏，Z_MEM_ERROR 内存不足等）。遇到错误应立即退出循环并处理。
- 循环条件是 ret != Z_STREAM_END 且 strm.avail_in > 0。理论上解压成功应该会因为读到流结束标记而返回 Z_STREAM_END。如果输入耗尽 (strm.avail_in == 0) 但没有返回 Z_STREAM_END，可能意味着输入流不完整。
- 检查循环结束后 ret 是否为 Z_STREAM_END 以确认解压成功。
- strm.total_out 记录了实际解压出的总字节数。
- 最后调用 inflateEnd(&strm) 清理资源。
- 可选地，使用 realloc 将输出缓冲区大小调整为实际解压数据长度，以节省内存。
main 函数:
- 定义原始字符串数据。
- 调用 compress_buffer 进行压缩。
- 调用 decompress_buffer 进行解压缩。
- 使用 memcmp 比较解压后的数据和原始数据是否一致进行验证。
- 释放动态分配的内存。

这个示例展示了 zlib 的基本使用流程：初始化、循环处理数据、结束、清理。对于更复杂的流式处理，核心逻辑类似，只是循环中的输入/输出管理（例如从文件读取数据块，向文件写入数据块）会更复杂。

第五部分：进阶话题与应用场景

流式压缩与解压缩： 上述示例的解压缩部分已经初步展示了流式处理的思路。在实际应用中，你需要在一个循环中反复调用 deflate 或 inflate。每次调用前，更新 strm->next_in 和 strm->avail_in 为新的输入数据块，更新 strm->next_out 和 strm->avail_out 为可用的输出缓冲区空间。deflate 或 inflate 会尽可能多地处理数据，并在 strm->avail_in 或 strm->avail_out 耗尽时返回。你需要根据返回值和 avail_in/avail_out 的变化来决定是提供更多输入、处理已产生的输出、扩大输出缓冲区，还是结束循环。
内存管理： 对于内存受限的系统，可以通过 z_stream 结构体中的 zalloc 和 zfree 函数指针提供自定义的内存分配和释放逻辑，而不是依赖标准库的 malloc/free。
校验和的应用： 在压缩或解压缩过程中，z_stream 的 adler 字段会自动更新校验和。对于 zlib 格式，它计算 Adler-32；对于 gzip 格式，它计算 CRC-32。你可以在压缩或解压缩完成后，检查 strm->adler 的值与数据流中的校验和是否匹配，以验证数据完整性。也可以独立使用 adler32 和 crc32 函数计算任意数据的校验和。
不同的 windowBits 值： 理解 inflateInit2 和 deflateInit2 中 windowBits 参数的含义至关重要。选择正确的值才能确保压缩器输出的格式（原始 DEFLATE, zlib, gzip）与解压缩器期望的格式匹配。常见的选择是 15 (zlib 格式) 或 31 (gzip 格式)，而解压缩时使用 47 (自动检测 zlib 或 gzip) 是一个便利的选择。
错误处理： zlib 函数返回的错误码提供了丰富的信息。在生产代码中，必须检查每个 zlib 函数的返回值，并根据错误码进行相应的处理或记录日志。strm->msg 在某些错误情况下会包含更详细的错误描述。
与文件 I/O 结合： 实际应用中，zlib 常用于压缩/解压缩文件。这涉及到从文件读取数据块作为输入，将压缩/解压缩后的数据块写入文件。可以使用标准 C 库的 fread/fwrite 或 POSIX 系统的 read/write 函数配合 zlib 的流式 API 来实现。zlib 也提供了 gzFile 系列高级函数（如 gzopen, gzread, gzwrite, gzclose），它们封装了文件 I/O 和 zlib 压缩/解压缩，使用起来更简便，类似于操作普通文件句柄。
应用场景举例：
- 文件压缩工具： gzip, zip 等工具内部大量使用 zlib。
- 网络传输： HTTP 协议中的 Content-Encoding: gzip 使用 zlib 来压缩网页内容，减少传输延迟。
- 图片格式： PNG 图片格式使用 DEFLATE 算法来压缩像素数据。
- 软件分发和安装： 许多软件包格式和安装程序使用 zlib 压缩来减小文件大小。
- 数据备份和归档： 将数据进行 zlib 压缩后再进行备份或归档是常见的做法。
- 内存数据库或缓存： 对存储在内存中的数据进行压缩以节省内存空间。

第六部分：总结

zlib 是一个功能强大、高效且高度可移植的数据压缩库。它基于 DEFLATE 算法，巧妙结合了 LZ77 字典匹配和 Huffman 熵编码，在压缩率和速度之间取得了优秀的平衡。理解其核心 z_stream 结构体以及 deflateInit/inflateInit、deflate/inflate、deflateEnd/inflateEnd 这些函数是入门的关键。虽然直接使用核心 API 需要手动管理缓冲区和循环，但这提供了最大的灵活性，尤其适用于流式处理。对于简单的文件操作，可以使用 gzFile 系列函数简化开发。

掌握 zlib 的使用，将使你能够轻松地为你的应用程序添加数据压缩和解压缩功能，从而优化存储、提升传输效率，并处理各种使用 DEFLATE/zlib/gzip 格式的数据。尽管 DEFLATE 算法不是当前压缩率最高的算法（例如 Brotli, Zstd 在某些场景下表现更优），但凭借其广泛的应用、良好的性能、无专利限制以及成熟稳定的实现，zlib 在数据压缩领域仍然占据着不可替代的重要地位。

希望本文能帮助你深入理解 zlib 库的工作原理，并为你开启 zlib 应用的大门。在实际开发中，务必参考 zlib 官方文档以获取最详细和权威的信息。

zlib 数据压缩库详解与应用入门 – wiki基地

Zlib 数据压缩库详解与应用入门

include

include

include

include

发表评论取消回复

Zlib 数据压缩库详解与应用入门

include

include

include

include

发表评论 取消回复

发表评论取消回复