zlib库剖析(4)：使用示例example.c

骑猪看日落 2022-08-13 14:41 325阅读 0赞

下面分析test/example.c，它示范了zlib库的各个函数的使用。

下面代码定义要压缩的字符串、压缩时使用的字典、压缩/解压缩的内存分配策略等。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* example.c -- usage example of the zlib compression library 
2.   \* Copyright (C) 1995-2006, 2011 Jean-loup Gailly. 
3.   \* For conditions of distribution and use, see copyright notice in zlib.h 
4.   \*/  
5.    
6.  /\* @(\#) $Id$ \*/  
7.    
8.  \#include "zlib.h"  
9.  \#include <stdio.h>  
10.   
11. \#ifdef STDC  
12. \#  include <string.h>  
13. \#  include <stdlib.h>  
14. \#endif  
15.   
16. \#if defined(VMS) || defined(RISCOS)  
17. \#  define TESTFILE "foo-gz"  
18. \#else  
19. \#  define TESTFILE "foo.gz"  
20. \#endif  
21.   
22. \#define CHECK\_ERR(err, msg) \{ \\  
23.     **if** (err != Z\_OK) \{ \\  
24.         fprintf(stderr, "%s error: %d\\n", msg, err); \\  
25.         exit(1); \\  
26.     \} \\  
27. \}  
28.   
29. **const** **char** hello\[\] = "hello, hello!";  /\* 字符长度为14（末尾还有一个null字符） \*/  
30. /\* "hello world" would be more standard, but the repeated "hello" 
31.  \* stresses the compression code better, sorry... 
32.  \*/  
33.   
34. **const** **char** dictionary\[\] = "hello";  
35. uLong dictId; /\* 字典的Adler32校验值 \*/  
36.   
37. **void** test\_deflate       OF((Byte \*compr, uLong comprLen));  
38. **void** test\_inflate       OF((Byte \*compr, uLong comprLen,  
39.                             Byte \*uncompr, uLong uncomprLen));  
40. **void** test\_large\_deflate OF((Byte \*compr, uLong comprLen,  
41.                             Byte \*uncompr, uLong uncomprLen));  
42. **void** test\_large\_inflate OF((Byte \*compr, uLong comprLen,  
43.                             Byte \*uncompr, uLong uncomprLen));  
44. **void** test\_flush         OF((Byte \*compr, uLong \*comprLen));  
45. **void** test\_sync          OF((Byte \*compr, uLong comprLen,  
46.                             Byte \*uncompr, uLong uncomprLen));  
47. **void** test\_dict\_deflate  OF((Byte \*compr, uLong comprLen));  
48. **void** test\_dict\_inflate  OF((Byte \*compr, uLong comprLen,  
49.                             Byte \*uncompr, uLong uncomprLen));  
50. **int**  main               OF((**int** argc, **char** \*argv\[\]));  
51.   
52. /\* Z\_SOLO表示把zlib库编译成单独的不依赖第三方的库 \*/  
53. \#ifdef Z\_SOLO  
54.   
55. /\* 使用自定义的内存分配策略 \*/  
56. **void** \*myalloc OF((**void** \*, unsigned, unsigned));  
57. **void** myfree OF((**void** \*, **void** \*));  
58.   
59. **void** \*myalloc(q, n, m)  
60.     **void** \*q;  
61.     unsigned n, m;  
62. \{  
63.     q = Z\_NULL;  
64.     **return** calloc(n, m);  
65. \}  
66.   
67. **void** myfree(**void** \*q, **void** \*p)  
68. \{  
69.     q = Z\_NULL;  
70.     free(p);  
71. \}  
72.   
73. **static** alloc\_func zalloc = myalloc;  
74. **static** free\_func zfree = myfree;  
75.   
76. \#else /\* !Z\_SOLO \*/  
77.   
78. /\* 使用zlib默认的内存分配策略 \*/  
79. **static** alloc\_func zalloc = (alloc\_func)0;  
80. **static** free\_func zfree = (free\_func)0;

下面测试compress和uncompress的用法：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** test\_compress      OF((Byte \*compr, uLong comprLen,  
2.                              Byte \*uncompr, uLong uncomprLen));  
3.  **void** test\_gzio          OF((**const** **char** \*fname,  
4.                              Byte \*uncompr, uLong uncomprLen));  
5.    
6.  /\* =========================================================================== 
7.   \* 测试compress()和uncompress() 
8.   \*/  
9.  **void** test\_compress(compr, comprLen, uncompr, uncomprLen)  
10.     Byte \*compr, \*uncompr;  
11.     uLong comprLen, uncomprLen;  
12. \{  
13.     **int** err;  
14.     uLong len = (uLong)strlen(hello)+1; /\* 获取字符串长度 \*/  
15.       
16.     /\* 压缩字符串 \*/  
17.     err = compress(compr, &comprLen, (**const** Bytef\*)hello, len);  
18.     CHECK\_ERR(err, "compress");  
19.   
20.     strcpy((**char**\*)uncompr, "garbage");  
21.       
22.     /\* 解压字符串 \*/  
23.     err = uncompress(uncompr, &uncomprLen, compr, comprLen);  
24.     CHECK\_ERR(err, "uncompress");  
25.       
26.     /\* 比较解压后的结果 \*/  
27.     **if** (strcmp((**char**\*)uncompr, hello)) \{  
28.         fprintf(stderr, "bad uncompress\\n");  
29.         exit(1);  
30.     \} **else** \{  
31.         printf("uncompress(): %s\\n", (**char** \*)uncompr);  
32.     \}  
33. \}

下面测试gzip文件的读写操作：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* =========================================================================== 
2.   \* 测试.gz文件的读写操作 
3.   \*/  
4.  **void** test\_gzio(fname, uncompr, uncomprLen)  
5.      **const** **char** \*fname; /\* gz文件名 \*/  
6.      Byte \*uncompr;  
7.      uLong uncomprLen;  
8.  \{  
9.  \#ifdef NO\_GZCOMPRESS  
10.     fprintf(stderr, "NO\_GZCOMPRESS -- gz\* functions cannot compress\\n");  
11. \#else  
12.     **int** err;  
13.     **int** len = (**int**)strlen(hello)+1;  
14.     gzFile file;  
15.     z\_off\_t pos;  
16.   
17.     file = gzopen(fname, "wb");  /\* 打开要写入的gz文件 \*/  
18.     **if** (file == NULL) \{  
19.         fprintf(stderr, "gzopen error\\n");  
20.         exit(1);  
21.     \}  
22.     gzputc(file, 'h');  /\* 写入一个字符'h' \*/  
23.     **if** (gzputs(file, "ello") != 4) \{  /\* 写入字符串"ello" \*/  
24.         fprintf(stderr, "gzputs err: %s\\n", gzerror(file, &err));  
25.         exit(1);  
26.     \}  
27.     **if** (gzprintf(file, ", %s!", "hello") != 8) \{ /\* 按格式写入字符串", hello!" \*/  
28.         fprintf(stderr, "gzprintf err: %s\\n", gzerror(file, &err));  
29.         exit(1);  
30.     \}  
31.     gzseek(file, 1L, SEEK\_CUR); /\* 读写头向前移动1字节（即添加一个0字节） \*/  
32.     gzclose(file);  /\* 关闭gz文件 \*/  
33.   
34.     file = gzopen(fname, "rb");  /\* 打开要读取的gz文件 \*/  
35.     **if** (file == NULL) \{  
36.         fprintf(stderr, "gzopen error\\n");  
37.         exit(1);  
38.     \}  
39.     strcpy((**char**\*)uncompr, "garbage");  
40.       
41.     /\* 从压缩文件中读取给定大小的解压字节数 \*/  
42.     **if** (gzread(file, uncompr, (unsigned)uncomprLen) != len) \{  
43.         fprintf(stderr, "gzread err: %s\\n", gzerror(file, &err));  
44.         exit(1);  
45.     \}  
46.     **if** (strcmp((**char**\*)uncompr, hello)) \{  /\* 比较解压后的结果 \*/  
47.         fprintf(stderr, "bad gzread: %s\\n", (**char**\*)uncompr);  
48.         exit(1);  
49.     \} **else** \{  
50.         printf("gzread(): %s\\n", (**char**\*)uncompr);  
51.     \}  
52.   
53.     pos = gzseek(file, -8L, SEEK\_CUR);  /\* 读写头向后移动8字节，应该停留在第6个字符处 \*/  
54.     **if** (pos != 6 || gztell(file) != pos) \{  /\* 判断是否停留在第6个字符处 \*/  
55.         fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\\n",  
56.                 (**long**)pos, (**long**)gztell(file));  
57.         exit(1);  
58.     \}  
59.   
60.     **if** (gzgetc(file) != ' ') \{  /\* 从当前位置读取1个字符，应该为字符' ' \*/  
61.         fprintf(stderr, "gzgetc error\\n");  
62.         exit(1);  
63.     \}  
64.   
65.     **if** (gzungetc(' ', file) != ' ') \{  /\* 推回这个字符到流中 \*/  
66.         fprintf(stderr, "gzungetc error\\n");  
67.         exit(1);  
68.     \}  
69.       
70.     /\* 从压缩文件当前位置读取指定长度的解压字节数，直到len-1个字符被读取 \*/  
71.     gzgets(file, (**char**\*)uncompr, (**int**)uncomprLen);  
72.     **if** (strlen((**char**\*)uncompr) != 7) \{ /\* " hello!" \*/  
73.         fprintf(stderr, "gzgets err after gzseek: %s\\n", gzerror(file, &err));  
74.         exit(1);  
75.     \}  
76.     **if** (strcmp((**char**\*)uncompr, hello + 6)) \{  
77.         fprintf(stderr, "bad gzgets after gzseek\\n");  
78.         exit(1);  
79.     \} **else** \{  
80.         printf("gzgets() after gzseek: %s\\n", (**char**\*)uncompr);  
81.     \}  
82.   
83.     gzclose(file);  /\* 关闭gz文件 \*/  
84. \#endif  
85. \}  
86.   
87. \#endif /\* Z\_SOLO \*/

下面用小缓冲区测试压缩、解压操作（deflate/deflate）：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* =========================================================================== 
2.   \* 测试deflate()：使用小缓冲区 
3.   \*/  
4.  **void** test\_deflate(compr, comprLen)  
5.      Byte \*compr;  
6.      uLong comprLen;  
7.  \{  
8.      z\_stream c\_stream; /\* 压缩流 \*/  
9.      **int** err;  
10.     uLong len = (uLong)strlen(hello)+1;  
11.       
12.     /\* 这三个字段要在defalteInit之前初始化 \*/  
13.     c\_stream.zalloc = zalloc;  
14.     c\_stream.zfree = zfree;  
15.     c\_stream.opaque = (voidpf)0;  
16.       
17.     /\* 初始化压缩流的状态，使用默认压缩级别 \*/  
18.     err = deflateInit(&c\_stream, Z\_DEFAULT\_COMPRESSION);  
19.     CHECK\_ERR(err, "deflateInit");  
20.       
21.     /\* 设置压缩操作的输入数据和输出缓冲区 \*/  
22.     c\_stream.next\_in  = (Bytef\*)hello;  /\* 输入缓冲区指向输入字符串 \*/  
23.     c\_stream.next\_out = compr;  
24.   
25.     /\* 第一个循环：将flush设为Z\_NO\_FLUSH（表示还有输入数据未读完），将所有输入都读进去并进行压缩 
26.        根据avail\_in和avail\_out，不停地调用deflate将输入缓冲区的数据压缩 
27.        并写到输出缓冲区，直到输入字符串读完或输出缓冲区用完  
28.     \*/  
29.     **while** (c\_stream.total\_in != len && c\_stream.total\_out < comprLen) \{  
30.         c\_stream.avail\_in = c\_stream.avail\_out = 1; /\* 强制小缓冲区 \*/  
31.         err = deflate(&c\_stream, Z\_NO\_FLUSH);  
32.         CHECK\_ERR(err, "deflate");  
33.     \}  
34.     /\* 第二个循环：将flush设置为Z\_FINISH，不再输入，让deflate()完成全部的压缩输出 
35.        注意因为deflate压缩时可能是异步的（为了加速压缩，读取一次输入后不一定立刻就会产生压缩输出， 
36.        可能读完K字节后才会产生输出），所以上一个循环可能还没产生全部输出，需要这个循环，让flush保持Z\_FINISH 
37.        （表示输入数据已读完），多次调用deflate()，直到返回Z\_STREAM\_END，表示处理完全部输入并产生了全部的压缩输出  
38.     \*/  
39.     **for** (;;) \{  /\* 完成压缩流的刷新，仍然强制小缓冲区 \*/  
40.         c\_stream.avail\_out = 1;  
41.         err = deflate(&c\_stream, Z\_FINISH);  
42.         **if** (err == Z\_STREAM\_END) **break**;  
43.         CHECK\_ERR(err, "deflate");  
44.     \}  
45.   
46.     err = deflateEnd(&c\_stream);  /\* 释放压缩流的资源 \*/  
47.     CHECK\_ERR(err, "deflateEnd");  
48. \}  
49.   
50. /\* =========================================================================== 
51.  \* 测试inflate()：使用小缓冲区 
52.  \*/  
53. **void** test\_inflate(compr, comprLen, uncompr, uncomprLen)  
54.     Byte \*compr, \*uncompr;  
55.     uLong comprLen, uncomprLen;  
56. \{  
57.     **int** err;  
58.     z\_stream d\_stream; /\* 解压流 \*/  
59.   
60.     strcpy((**char**\*)uncompr, "garbage");  
61.   
62.     /\* 这些个字段要在infalteInit之前初始化 \*/  
63.     d\_stream.zalloc = zalloc;  
64.     d\_stream.zfree = zfree;  
65.     d\_stream.opaque = (voidpf)0;  
66.   
67.     d\_stream.next\_in  = compr;  /\* 设置输入缓冲区 \*/  
68.     d\_stream.avail\_in = 0;  
69.     d\_stream.next\_out = uncompr;  /\* 设置输出缓冲区 \*/  
70.   
71.     /\* 初始化解压流的状态 \*/  
72.     err = inflateInit(&d\_stream);  
73.     CHECK\_ERR(err, "inflateInit");  
74.   
75.     /\* 只需一个循环：根据avail\_in和avail\_out，不停地调用inflate将输入缓冲区的数据 
76.        解压，直到返回Z\_STREAM\_END，表示处理完全部输入并产生了全部的解压输出 
77.        这里与flush参数是否为Z\_FINISH无关 
78.     \*/  
79.     **while** (d\_stream.total\_out < uncomprLen && d\_stream.total\_in < comprLen) \{  
80.         d\_stream.avail\_in = d\_stream.avail\_out = 1; /\* 强制小缓冲区 \*/  
81.         err = inflate(&d\_stream, Z\_NO\_FLUSH);  
82.         **if** (err == Z\_STREAM\_END) **break**;  
83.         CHECK\_ERR(err, "inflate");  
84.     \}  
85.   
86.     err = inflateEnd(&d\_stream);  /\* 释放解压流的资源 \*/  
87.     CHECK\_ERR(err, "inflateEnd");  
88.   
89.     **if** (strcmp((**char**\*)uncompr, hello)) \{  /\* 比较解压后的数据 \*/  
90.         fprintf(stderr, "bad inflate\\n");  
91.         exit(1);  
92.     \} **else** \{  
93.         printf("inflate(): %s\\n", (**char** \*)uncompr);  
94.     \}  
95. \}

下面使用大缓冲区测试压缩、解压操作（deflate/deflate）：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* =========================================================================== 
2.   \* 测试deflate()：使用大缓冲区和动态改变的压缩级别 
3.   \*/  
4.  **void** test\_large\_deflate(compr, comprLen, uncompr, uncomprLen)  
5.      Byte \*compr, \*uncompr;  
6.      uLong comprLen, uncomprLen;  
7.  \{  
8.      z\_stream c\_stream; /\* 压缩流 \*/  
9.      **int** err;  
10.   
11.     /\* 这三个字段要在defalteInit之前初始化 \*/  
12.     c\_stream.zalloc = zalloc;  
13.     c\_stream.zfree = zfree;  
14.     c\_stream.opaque = (voidpf)0;  
15.   
16.     /\* 初始化压缩流的状态，使用最快速度压缩 \*/  
17.     err = deflateInit(&c\_stream, Z\_BEST\_SPEED);  
18.     CHECK\_ERR(err, "deflateInit");  
19.   
20.     c\_stream.next\_out = compr;  
21.     c\_stream.avail\_out = (uInt)comprLen;  
22.   
23.     /\* 这里，uncompr几乎都为0，因此可以很好地被压缩 \*/  
24.     c\_stream.next\_in = uncompr;  
25.     c\_stream.avail\_in = (uInt)uncomprLen;  
26.     err = deflate(&c\_stream, Z\_NO\_FLUSH); /\* 压缩输入数据 \*/  
27.     CHECK\_ERR(err, "deflate");  
28.     **if** (c\_stream.avail\_in != 0) \{  
29.         fprintf(stderr, "deflate not greedy\\n");  
30.         exit(1);  
31.     \}  
32.   
33.     /\* 把已压缩的数据转换成未压缩: \*/  
34.       
35.     /\* 设置流的压缩级别（为未压缩）和压缩策略 \*/  
36.     deflateParams(&c\_stream, Z\_NO\_COMPRESSION, Z\_DEFAULT\_STRATEGY);  
37.     c\_stream.next\_in = compr;  
38.     c\_stream.avail\_in = (uInt)comprLen/2;  
39.     err = deflate(&c\_stream, Z\_NO\_FLUSH);  
40.     CHECK\_ERR(err, "deflate");  
41.   
42.     /\* 转换回压缩模式（最高压缩率）: \*/  
43.     deflateParams(&c\_stream, Z\_BEST\_COMPRESSION, Z\_FILTERED);  
44.     c\_stream.next\_in = uncompr;  
45.     c\_stream.avail\_in = (uInt)uncomprLen;  
46.     err = deflate(&c\_stream, Z\_NO\_FLUSH);  
47.     CHECK\_ERR(err, "deflate");  
48.   
49.     /\* 流刷新，产生全部压缩输出 \*/  
50.     err = deflate(&c\_stream, Z\_FINISH);  
51.     **if** (err != Z\_STREAM\_END) \{  
52.         fprintf(stderr, "deflate should report Z\_STREAM\_END\\n");  
53.         exit(1);  
54.     \}  
55.     err = deflateEnd(&c\_stream);  /\* 释放流的资源 \*/  
56.     CHECK\_ERR(err, "deflateEnd");  
57. \}  
58.   
59. /\* =========================================================================== 
60.  \* 测试inflate()：使用大缓冲区 
61.  \*/  
62. **void** test\_large\_inflate(compr, comprLen, uncompr, uncomprLen)  
63.     Byte \*compr, \*uncompr;  
64.     uLong comprLen, uncomprLen;  
65. \{  
66.     **int** err;  
67.     z\_stream d\_stream; /\* 解压流 \*/  
68.   
69.     strcpy((**char**\*)uncompr, "garbage");  
70.   
71.     /\* 这些个字段要在infalteInit之前初始化 \*/  
72.     d\_stream.zalloc = zalloc;  
73.     d\_stream.zfree = zfree;  
74.     d\_stream.opaque = (voidpf)0;  
75.   
76.     d\_stream.next\_in  = compr;  
77.     d\_stream.avail\_in = (uInt)comprLen;  
78.   
79.     /\* 初始化解压流 \*/  
80.     err = inflateInit(&d\_stream);  
81.     CHECK\_ERR(err, "inflateInit");  
82.   
83.     /\* 解压 \*/  
84.     **for** (;;) \{  
85.         d\_stream.next\_out = uncompr;            /\* 抛弃输出 \*/  
86.         d\_stream.avail\_out = (uInt)uncomprLen;  
87.         err = inflate(&d\_stream, Z\_NO\_FLUSH);  /\* 解压输入数据 \*/  
88.         **if** (err == Z\_STREAM\_END) **break**;  
89.         CHECK\_ERR(err, "large inflate");  
90.     \}  
91.   
92.     err = inflateEnd(&d\_stream);  
93.     CHECK\_ERR(err, "inflateEnd");  
94.   
95.     **if** (d\_stream.total\_out != 2\*uncomprLen + comprLen/2) \{  
96.         fprintf(stderr, "bad large inflate: %ld\\n", d\_stream.total\_out);  
97.         exit(1);  
98.     \} **else** \{  
99.         printf("large\_inflate(): OK\\n");  
100.     \}  
101. \}

下面使用完全刷新模式测试压缩操作deflate：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* =========================================================================== 
2.   \* 测试deflate()：使用完全刷新 
3.   \*/  
4.  **void** test\_flush(compr, comprLen)  
5.      Byte \*compr;  
6.      uLong \*comprLen;  
7.  \{  
8.      z\_stream c\_stream; /\* 压缩流 \*/  
9.      **int** err;  
10.     uInt len = (uInt)strlen(hello)+1;  
11.   
12.     c\_stream.zalloc = zalloc;  
13.     c\_stream.zfree = zfree;  
14.     c\_stream.opaque = (voidpf)0;  
15.   
16.     err = deflateInit(&c\_stream, Z\_DEFAULT\_COMPRESSION);  
17.     CHECK\_ERR(err, "deflateInit");  
18.   
19.     c\_stream.next\_in  = (Bytef\*)hello;  
20.     c\_stream.next\_out = compr;  
21.     c\_stream.avail\_in = 3;  
22.     c\_stream.avail\_out = (uInt)\*comprLen;  
23.     /\* 使用完全刷新来压缩字符串 \*/  
24.     err = deflate(&c\_stream, Z\_FULL\_FLUSH);  
25.     CHECK\_ERR(err, "deflate");  
26.   
27.     compr\[3\]++; /\* 在第一个压缩块中强制产生一个错误 \*/  
28.     c\_stream.avail\_in = len - 3;  
29.   
30.     err = deflate(&c\_stream, Z\_FINISH);  
31.     **if** (err != Z\_STREAM\_END) \{  
32.         CHECK\_ERR(err, "deflate");  
33.     \}  
34.     err = deflateEnd(&c\_stream);  
35.     CHECK\_ERR(err, "deflateEnd");  
36.   
37.     \*comprLen = c\_stream.total\_out;  
38. \}

下面测试同步方式的解压操作inflateSync：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* =========================================================================== 
2.   \* Test inflateSync() 
3.   \*/  
4.  **void** test\_sync(compr, comprLen, uncompr, uncomprLen)  
5.      Byte \*compr, \*uncompr;  
6.      uLong comprLen, uncomprLen;  
7.  \{  
8.      **int** err;  
9.      z\_stream d\_stream; /\* 解压流 \*/  
10.   
11.     strcpy((**char**\*)uncompr, "garbage");  
12.   
13.     d\_stream.zalloc = zalloc;  
14.     d\_stream.zfree = zfree;  
15.     d\_stream.opaque = (voidpf)0;  
16.   
17.     d\_stream.next\_in  = compr;  /\* 设置输入缓冲区 \*/  
18.     d\_stream.avail\_in = 2; /\* 只读取zlib头部信息 \*/  
19.   
20.     err = inflateInit(&d\_stream);  
21.     CHECK\_ERR(err, "inflateInit");  
22.   
23.     d\_stream.next\_out = uncompr;  /\* 设置输出缓冲区 \*/  
24.     d\_stream.avail\_out = (uInt)uncomprLen;  
25.   
26.     inflate(&d\_stream, Z\_NO\_FLUSH);  
27.     CHECK\_ERR(err, "inflate");  
28.   
29.     d\_stream.avail\_in = (uInt)comprLen-2;   /\* 读取所有压缩数据 \*/  
30.     err = inflateSync(&d\_stream);           /\* 但忽略损坏的部分 \*/  
31.     CHECK\_ERR(err, "inflateSync");  
32.   
33.     err = inflate(&d\_stream, Z\_FINISH);  /\* 完成解压 \*/  
34.     **if** (err != Z\_DATA\_ERROR) \{  
35.         fprintf(stderr, "inflate should report DATA\_ERROR\\n");  
36.         /\* 因为不正确的adler32 \*/  
37.         exit(1);  
38.     \}  
39.     err = inflateEnd(&d\_stream);  
40.     CHECK\_ERR(err, "inflateEnd");  
41.   
42.     printf("after inflateSync(): hel%s\\n", (**char** \*)uncompr);  
43. \}

下面用预设的字典测试压缩、解压操作（deflate/inflate）:

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* =========================================================================== 
2.   \* 测试：deflate()：使用预设的字典 
3.   \*/  
4.  **void** test\_dict\_deflate(compr, comprLen)  
5.      Byte \*compr;  
6.      uLong comprLen;  
7.  \{  
8.      z\_stream c\_stream; /\* 压缩流 \*/  
9.      **int** err;  
10.   
11.     c\_stream.zalloc = zalloc;  
12.     c\_stream.zfree = zfree;  
13.     c\_stream.opaque = (voidpf)0;  
14.   
15.     err = deflateInit(&c\_stream, Z\_BEST\_COMPRESSION);  
16.     CHECK\_ERR(err, "deflateInit");  
17.   
18.     /\* 设置压缩流要使用的字典 \*/  
19.     err = deflateSetDictionary(&c\_stream,  
20.                 (**const** Bytef\*)dictionary, (**int**)**sizeof**(dictionary));  
21.     CHECK\_ERR(err, "deflateSetDictionary");  
22.   
23.     dictId = c\_stream.adler;  /\* 得到字典的Alder32校验值 \*/  
24.     c\_stream.next\_out = compr;  
25.     c\_stream.avail\_out = (uInt)comprLen;  
26.   
27.     c\_stream.next\_in = (Bytef\*)hello; /\* 输入要压缩的字符串 \*/  
28.     c\_stream.avail\_in = (uInt)strlen(hello)+1;  
29.   
30.     /\* 直接进行压缩 \*/  
31.     err = deflate(&c\_stream, Z\_FINISH);  
32.     **if** (err != Z\_STREAM\_END) \{  
33.         fprintf(stderr, "deflate should report Z\_STREAM\_END\\n");  
34.         exit(1);  
35.     \}  
36.     err = deflateEnd(&c\_stream);  
37.     CHECK\_ERR(err, "deflateEnd");  
38. \}  
39.   
40. /\* =========================================================================== 
41.  \* 测试inflate()：使用预设的字典 
42.  \*/  
43. **void** test\_dict\_inflate(compr, comprLen, uncompr, uncomprLen)  
44.     Byte \*compr, \*uncompr;  
45.     uLong comprLen, uncomprLen;  
46. \{  
47.     **int** err;  
48.     z\_stream d\_stream; /\* 解压流 \*/  
49.   
50.     strcpy((**char**\*)uncompr, "garbage");  
51.   
52.     d\_stream.zalloc = zalloc;  
53.     d\_stream.zfree = zfree;  
54.     d\_stream.opaque = (voidpf)0;  
55.   
56.     d\_stream.next\_in  = compr;  
57.     d\_stream.avail\_in = (uInt)comprLen;  
58.   
59.     err = inflateInit(&d\_stream);  
60.     CHECK\_ERR(err, "inflateInit");  
61.   
62.     d\_stream.next\_out = uncompr;  
63.     d\_stream.avail\_out = (uInt)uncomprLen;  
64.   
65.     **for** (;;) \{  /\* 解压 \*/  
66.         err = inflate(&d\_stream, Z\_NO\_FLUSH);  
67.         **if** (err == Z\_STREAM\_END) **break**;  
68.         **if** (err == Z\_NEED\_DICT) \{  /\* 如果需要字典 \*/  
69.             **if** (d\_stream.adler != dictId) \{  /\* 校验是否与压缩时的字典值一致 \*/  
70.                 fprintf(stderr, "unexpected dictionary");  
71.                 exit(1);  
72.             \}  
73.             /\* 设置解压需要的字典 \*/  
74.             err = inflateSetDictionary(&d\_stream, (**const** Bytef\*)dictionary,  
75.                                        (**int**)**sizeof**(dictionary));  
76.         \}  
77.         CHECK\_ERR(err, "inflate with dict");  
78.     \}  
79.   
80.     err = inflateEnd(&d\_stream);  
81.     CHECK\_ERR(err, "inflateEnd");  
82.   
83.     **if** (strcmp((**char**\*)uncompr, hello)) \{  /\* 比较解压后的字符串 \*/  
84.         fprintf(stderr, "bad inflate with dict\\n");  
85.         exit(1);  
86.     \} **else** \{  
87.         printf("inflate with dictionary: %s\\n", (**char** \*)uncompr);  
88.     \}  
89. \}

下面是命令行程序：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* =========================================================================== 
2.   \* Usage:  example \[output.gz  \[input.gz\]\] 
3.   \*/  
4.    
5.  **int** main(argc, argv)  
6.      **int** argc;  
7.      **char** \*argv\[\];  
8.  \{  
9.      Byte \*compr, \*uncompr;  
10.     uLong comprLen = 10000\***sizeof**(**int**); /\* 在MSDOS上不会溢出 \*/  
11.     uLong uncomprLen = comprLen;  
12.     **static** **const** **char**\* myVersion = ZLIB\_VERSION;  
13.   
14.     /\* 检查zlib版本是否一致 \*/  
15.     **if** (zlibVersion()\[0\] != myVersion\[0\]) \{  
16.         fprintf(stderr, "incompatible zlib version\\n");  
17.         exit(1);  
18.   
19.     \} **else** **if** (strcmp(zlibVersion(), ZLIB\_VERSION) != 0) \{  
20.         fprintf(stderr, "warning: different zlib version\\n");  
21.     \}  
22.   
23.     /\* 打印版本和zlib编译信息 \*/  
24.     printf("zlib version %s = 0x%04x, compile flags = 0x%lx\\n",  
25.             ZLIB\_VERSION, ZLIB\_VERNUM, zlibCompileFlags());  
26.   
27.     /\* 分配输入、输出缓冲区的内存 \*/  
28.     compr    = (Byte\*)calloc((uInt)comprLen, 1);  
29.     uncompr  = (Byte\*)calloc((uInt)uncomprLen, 1);  
30.     /\* 清空compr和uncompr，以避免读到未初始化的数据，并且确保uncompr能很好 
31.      \* 地被压缩 
32.      \*/  
33.     **if** (compr == Z\_NULL || uncompr == Z\_NULL) \{  
34.         printf("out of memory\\n");  
35.         exit(1);  
36.     \}  
37.   
38.     /\* 下面运行各个测试函数 \*/  
39. \#ifdef Z\_SOLO  
40.     argc = strlen(argv\[0\]);  
41. \#else  
42.     test\_compress(compr, comprLen, uncompr, uncomprLen);  
43.   
44.     test\_gzio((argc > 1 ? argv\[1\] : TESTFILE),  
45.               uncompr, uncomprLen);  
46. \#endif  
47.   
48.     test\_deflate(compr, comprLen);  
49.     test\_inflate(compr, comprLen, uncompr, uncomprLen);  
50.   
51.     test\_large\_deflate(compr, comprLen, uncompr, uncomprLen);  
52.     test\_large\_inflate(compr, comprLen, uncompr, uncomprLen);  
53.   
54.     test\_flush(compr, &comprLen);  
55.     test\_sync(compr, comprLen, uncompr, uncomprLen);  
56.     comprLen = uncomprLen;  
57.   
58.     test\_dict\_deflate(compr, comprLen);  
59.     test\_dict\_inflate(compr, comprLen, uncompr, uncomprLen);  
60.   
61.     /\* 释放缓冲区资源 \*/  
62.     free(compr);  
63.     free(uncompr);  
64.   
65.     **return** 0;

1.  \}

转帖：http://blog.csdn.net/zhoudaxia/article/details/8039540

[view plain]: http://blog.csdn.net/zhoudaxia/article/details/8039540#