内存压缩：使用zlib实现在内存压缩STL容器-C++-PHP中文网

内存压缩：使用zlib实现在内存压缩STL容器

絕刀狂花

发布： 2025-06-25 22:11:01

原创

957人浏览过

内存压缩stl容器是为了降低内存占用，适用于大数据集处理。具体实现步骤：1.将stl容器数据序列化为字节流；2.使用zlib进行压缩并存储到新容器；3.解压时反向操作。压缩级别选择需权衡cpu时间和压缩率，实时性要求高选低级别，内存敏感选高级别，6为常用折中方案。错误处理应检查zlib返回码并采取对应措施，如释放内存或重试。除zlib外，lz4、snappy、brotli和zstandard等库也可根据速度与压缩率需求选用。压缩数据存储或传输时需附原始大小信息以便正确解压。

内存压缩：使用zlib实现在内存压缩STL容器

内存压缩，简单来说，就是减少数据在内存中占用的空间。使用zlib来压缩STL容器，可以有效降低内存占用，尤其是在处理大数据集时。

实现思路：将STL容器中的数据序列化成字节流，然后使用zlib进行压缩，压缩后的数据存储在新的容器中。解压时，反向操作即可。

为什么要在内存中压缩STL容器？

直接点说，就是为了省内存。想象一下，你有一个巨大的std::vector，每个MyObject都包含大量数据。如果不压缩，这个vector可能会占用几个GB的内存。如果使用zlib压缩，可以将内存占用降低到原来的几分之一，甚至更低。这对于内存受限的系统，或者需要同时处理多个大数据集的应用来说，至关重要。此外，压缩后的数据在传输时也能节省带宽。

如何选择合适的压缩级别？

zlib提供了多种压缩级别，从1（最快，压缩率最低）到9（最慢，压缩率最高）。选择合适的压缩级别需要在CPU时间和压缩率之间进行权衡。对于实时性要求高的应用，可以选择较低的压缩级别；对于对内存占用非常敏感的应用，可以选择较高的压缩级别。通常，级别6是一个不错的折中方案。你可以通过实验来找到最适合你的应用的压缩级别。另外，还可以考虑使用zlib提供的deflateBound()函数来预估压缩后的数据大小，避免内存溢出。

如何处理压缩和解压过程中的错误？

zlib的函数调用可能会返回错误码，例如Z_OK表示成功，Z_MEM_ERROR表示内存错误，Z_STREAM_ERROR表示数据流错误等等。在编写代码时，必须检查这些错误码，并采取相应的处理措施。例如，如果deflateInit()返回Z_MEM_ERROR，说明内存不足，应该释放一些内存或者终止程序。如果inflate()返回Z_DATA_ERROR，说明数据损坏，应该尝试重新获取数据或者通知用户。一个好的实践是，使用try-catch块来捕获异常，并记录错误信息，方便调试。

#include <iostream>
#include <vector>
#include <zlib.h>
#include <sstream>

// 简单的示例，压缩 std::vector<int>
std::vector<unsigned char> compress(const std::vector<int>& data) {
    std::stringstream ss;
    for (int val : data) {
        ss.write(reinterpret_cast<const char*>(&val), sizeof(int));
    }
    std::string data_str = ss.str();

    z_stream zs;
    memset(&zs, 0, sizeof(zs));

    if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
        throw std::runtime_error("deflateInit failed while compressing.");
    }

    zs.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(data_str.data()));
    zs.avail_in = data_str.size();

    int chunk_size = 16384;
    std::vector<unsigned char> compressed_data;

    do {
        unsigned char out_buffer[chunk_size];
        zs.next_out = reinterpret_cast<Bytef*>(out_buffer);
        zs.avail_out = chunk_size;

        int deflate_status = deflate(&zs, Z_FINISH);

        if (deflate_status != Z_OK && deflate_status != Z_STREAM_END) {
            deflateEnd(&zs);
            throw std::runtime_error("deflate failed while compressing.");
        }

        size_t compressed_bytes = chunk_size - zs.avail_out;
        compressed_data.insert(compressed_data.end(), out_buffer, out_buffer + compressed_bytes);

    } while (zs.avail_out == 0);

    deflateEnd(&zs);

    return compressed_data;
}

std::vector<int> decompress(const std::vector<unsigned char>& compressed_data, size_t original_size) {
    z_stream zs;
    memset(&zs, 0, sizeof(zs));

    if (inflateInit(&zs) != Z_OK) {
        throw std::runtime_error("inflateInit failed while decompressing.");
    }

    zs.next_in = reinterpret_cast<Bytef*>(const_cast<unsigned char*>(compressed_data.data()));
    zs.avail_in = compressed_data.size();

    std::vector<int> decompressed_data(original_size / sizeof(int)); // 预分配空间
    zs.next_out = reinterpret_cast<Bytef*>(decompressed_data.data());
    zs.avail_out = original_size;

    int inflate_status = inflate(&zs, Z_FINISH);

    if (inflate_status != Z_STREAM_END) {
        inflateEnd(&zs);
        throw std::runtime_error("inflate failed while decompressing.");
    }

    inflateEnd(&zs);
    return decompressed_data;
}

int main() {
    std::vector<int> original_data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    size_t original_size = original_data.size() * sizeof(int);

    try {
        std::vector<unsigned char> compressed_data = compress(original_data);
        std::cout << "Original size: " << original_size << " bytes" << std::endl;
        std::cout << "Compressed size: " << compressed_data.size() << " bytes" << std::endl;

        std::vector<int> decompressed_data = decompress(compressed_data, original_size);

        // 验证解压后的数据
        if (original_data == decompressed_data) {
            std::cout << "Decompression successful!" << std::endl;
        } else {
            std::cout << "Decompression failed!" << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

登录后复制

除了zlib，还有其他压缩库可以选择吗？

当然有。zlib虽然广泛使用，但并不是唯一的选择。还有其他的压缩库，例如：

LZ4: 以速度快著称，压缩率相对较低。适合对性能要求极高的场景。
Snappy: Google开发的压缩库，速度和压缩率都比较均衡。
Brotli: Google开发的另一种压缩库，压缩率比zlib更高，但速度相对较慢。
Zstandard (zstd): Facebook开发的压缩库，提供了多种压缩级别，可以在速度和压缩率之间进行灵活调整。

选择哪个压缩库取决于你的具体需求。如果你最关心速度，可以选择LZ4或Snappy；如果你最关心压缩率，可以选择Brotli或Zstandard；如果需要在速度和压缩率之间进行权衡，可以选择zlib或Zstandard。在选择之前，最好对不同的压缩库进行benchmark测试，找到最适合你的应用的库。

如何将压缩后的数据存储到磁盘或者通过网络传输？

压缩后的数据本质上是一段字节流，可以像任何其他数据一样存储到磁盘或者通过网络传输。存储到磁盘时，可以将压缩后的数据直接写入文件。通过网络传输时，可以将压缩后的数据封装到网络协议中，例如HTTP或TCP。需要注意的是，在存储或传输压缩后的数据时，需要同时保存原始数据的大小，以便解压时正确分配内存。一种常见的做法是在压缩后的数据前面加上一个header，header中包含原始数据的大小和其他元数据。接收方在接收到数据后，首先读取header，获取原始数据的大小，然后分配内存，最后解压数据。

以上就是内存压缩：使用zlib实现在内存压缩STL容器的详细内容，更多请关注php中文网其它相关文章！