C++ LZW 文件压缩算法实现

ytttr8732026-04-24 10:02

C++ LZW 文件压缩工具，包含压缩、解压、位流读写等功能：

项目结构

复制代码 
lzw_compressor/
├── lzw_compressor.cpp  # 主程序
├── bitstream.h         # 位流读写
└── lzw_algorithm.h     # LZW 核心算法

位流读写头文件 (bitstream.h)

cpp 复制代码 
#pragma once
#include <fstream>
#include <vector>
#include <cstdint>
#include <stdexcept>

class BitWriter {
private:
    std::ofstream& out;
    uint8_t buffer = 0;
    int bitCount = 0;
    
public:
    explicit BitWriter(std::ofstream& stream) : out(stream) {}
    
    void writeBits(uint16_t code, int bits) {
        for (int i = 0; i < bits; i++) {
            if (code & (1 << i)) {
                buffer |= (1 << bitCount);
            }
            bitCount++;
            
            if (bitCount == 8) {
                out.put(buffer);
                buffer = 0;
                bitCount = 0;
            }
        }
    }
    
    void flush() {
        if (bitCount > 0) {
            out.put(buffer);
            buffer = 0;
            bitCount = 0;
        }
    }
    
    ~BitWriter() { flush(); }
};

class BitReader {
private:
    std::ifstream& in;
    uint8_t buffer = 0;
    int bitPos = 8;  // 开始状态：缓冲区为空
    
public:
    explicit BitReader(std::ifstream& stream) : in(stream) {}
    
    int readBits(int bits) {
        uint16_t result = 0;
        
        for (int i = 0; i < bits; i++) {
            if (bitPos == 8) {  // 需要读取新字节
                int byte = in.get();
                if (byte == EOF) {
                    return -1;  // 文件结束
                }
                buffer = static_cast<uint8_t>(byte);
                bitPos = 0;
            }
            
            if (buffer & (1 << bitPos)) {
                result |= (1 << i);
            }
            bitPos++;
        }
        
        return result;
    }
    
    bool eof() const {
        return in.eof();
    }
};

LZW 核心算法 (lzw_algorithm.h)

cpp 复制代码 
#pragma once
#include "bitstream.h"
#include <unordered_map>
#include <vector>
#include <string>
#include <fstream>
#include <iostream>
#include <cstring>

class LZWCompressor {
private:
    static const int MAX_BITS = 12;
    static const int MAX_DICT_SIZE = 1 << MAX_BITS;  // 4096
    static const int CLEAR_CODE = 256;
    static const int END_CODE = 257;
    
public:
    // 压缩文件
    static bool compressFile(const std::string& inputFile, 
                            const std::string& outputFile) {
        std::ifstream in(inputFile, std::ios::binary);
        if (!in.is_open()) {
            std::cerr << "Error: Cannot open input file: " << inputFile << std::endl;
            return false;
        }
        
        std::ofstream out(outputFile, std::ios::binary);
        if (!out.is_open()) {
            std::cerr << "Error: Cannot create output file: " << outputFile << std::endl;
            return false;
        }
        
        // 写入文件头：4字节的魔数 "LZW "
        out.write("LZW ", 4);
        
        // 获取文件大小
        in.seekg(0, std::ios::end);
        size_t fileSize = in.tellg();
        in.seekg(0, std::ios::beg);
        
        // 写入原始文件大小
        out.write(reinterpret_cast<char*>(&fileSize), sizeof(fileSize));
        
        // 创建字典
        std::unordered_map<std::string, int> dict;
        for (int i = 0; i < 256; i++) {
            dict[std::string(1, char(i))] = i;
        }
        
        int nextCode = 258;  // 下一个可用码字
        BitWriter bitWriter(out);
        
        // 写入 CLEAR_CODE
        bitWriter.writeBits(CLEAR_CODE, MAX_BITS);
        
        // 压缩主循环
        std::string current;
        char ch;
        
        while (in.get(ch)) {
            std::string newStr = current + ch;
            
            if (dict.find(newStr) != dict.end()) {
                current = newStr;
            } else {
                // 输出当前字符串的码字
                bitWriter.writeBits(dict[current], MAX_BITS);
                
                // 如果字典未满，添加新字符串
                if (nextCode < MAX_DICT_SIZE) {
                    dict[newStr] = nextCode++;
                }
                
                // 重置当前字符串
                current = std::string(1, ch);
            }
        }
        
        // 输出最后一个字符串
        if (!current.empty()) {
            bitWriter.writeBits(dict[current], MAX_BITS);
        }
        
        // 写入结束码
        bitWriter.writeBits(END_CODE, MAX_BITS);
        bitWriter.flush();
        
        in.close();
        out.close();
        
        // 计算压缩率
        std::ifstream compressed(outputFile, std::ios::binary | std::ios::ate);
        size_t compressedSize = compressed.tellg();
        compressed.close();
        
        double ratio = 100.0 - (compressedSize * 100.0 / fileSize);
        
        std::cout << "Compression complete!" << std::endl;
        std::cout << "Original size: " << fileSize << " bytes" << std::endl;
        std::cout << "Compressed size: " << compressedSize << " bytes" << std::endl;
        std::cout << "Compression ratio: " << ratio << "%" << std::endl;
        
        return true;
    }
    
    // 解压文件
    static bool decompressFile(const std::string& inputFile, 
                              const std::string& outputFile) {
        std::ifstream in(inputFile, std::ios::binary);
        if (!in.is_open()) {
            std::cerr << "Error: Cannot open input file: " << inputFile << std::endl;
            return false;
        }
        
        // 检查文件头
        char magic[5] = {0};
        in.read(magic, 4);
        if (std::strncmp(magic, "LZW ", 4) != 0) {
            std::cerr << "Error: Not a valid LZW compressed file!" << std::endl;
            return false;
        }
        
        // 读取原始文件大小
        size_t originalSize = 0;
        in.read(reinterpret_cast<char*>(&originalSize), sizeof(originalSize));
        
        std::ofstream out(outputFile, std::ios::binary);
        if (!out.is_open()) {
            std::cerr << "Error: Cannot create output file: " << outputFile << std::endl;
            return false;
        }
        
        // 初始化字典
        std::vector<std::string> dict(256);
        for (int i = 0; i < 256; i++) {
            dict[i] = std::string(1, char(i));
        }
        
        int nextCode = 258;
        BitReader bitReader(in);
        
        // 读取第一个码字（跳过 CLEAR_CODE）
        int code = bitReader.readBits(MAX_BITS);
        if (code != CLEAR_CODE) {
            std::cerr << "Error: Invalid LZW file format!" << std::endl;
            return false;
        }
        
        // 读取第一个有效码字
        code = bitReader.readBits(MAX_BITS);
        if (code == END_CODE || code == -1) {
            std::cerr << "Error: Empty compressed file!" << std::endl;
            return false;
        }
        
        std::string prev = dict[code];
        out.write(prev.data(), prev.size());
        size_t bytesWritten = prev.size();
        
        // 解压主循环
        while (true) {
            code = bitReader.readBits(MAX_BITS);
            
            if (code == END_CODE || code == -1) {
                break;  // 文件结束
            }
            
            std::string entry;
            
            if (code < static_cast<int>(dict.size())) {
                entry = dict[code];
            } else if (code == nextCode) {
                // 处理特殊情况
                entry = prev + prev[0];
            } else {
                std::cerr << "Error: Invalid LZW code: " << code << std::endl;
                return false;
            }
            
            // 输出解压数据
            out.write(entry.data(), entry.size());
            bytesWritten += entry.size();
            
            // 检查是否已写入所有数据
            if (bytesWritten >= originalSize) {
                break;
            }
            
            // 添加新条目到字典
            if (nextCode < MAX_DICT_SIZE) {
                dict.push_back(prev + entry[0]);
                nextCode++;
            }
            
            prev = entry;
        }
        
        in.close();
        out.close();
        
        std::cout << "Decompression complete!" << std::endl;
        std::cout << "Decompressed size: " << bytesWritten << " bytes" << std::endl;
        
        return true;
    }
};

主程序 (lzw_compressor.cpp)

cpp 复制代码 
#include "lzw_algorithm.h"
#include <iostream>
#include <string>

void printUsage() {
    std::cout << "LZW File Compressor" << std::endl;
    std::cout << "Usage:" << std::endl;
    std::cout << "  Compress:   lzw_compressor -c <input_file> <output_file>" << std::endl;
    std::cout << "  Decompress: lzw_compressor -d <input_file> <output_file>" << std::endl;
    std::cout << std::endl;
    std::cout << "Examples:" << std::endl;
    std::cout << "  lzw_compressor -c document.txt document.lzw" << std::endl;
    std::cout << "  lzw_compressor -d document.lzw document_decompressed.txt" << std::endl;
}

int main(int argc, char* argv[]) {
    if (argc != 4) {
        printUsage();
        return 1;
    }
    
    std::string mode = argv[1];
    std::string inputFile = argv[2];
    std::string outputFile = argv[3];
    
    bool success = false;
    
    if (mode == "-c" || mode == "--compress") {
        std::cout << "Compressing " << inputFile << " to " << outputFile << "..." << std::endl;
        success = LZWCompressor::compressFile(inputFile, outputFile);
    } 
    else if (mode == "-d" || mode == "--decompress") {
        std::cout << "Decompressing " << inputFile << " to " << outputFile << "..." << std::endl;
        success = LZWCompressor::decompressFile(inputFile, outputFile);
    }
    else {
        std::cerr << "Error: Unknown mode '" << mode << "'" << std::endl;
        printUsage();
        return 1;
    }
    
    if (!success) {
        std::cerr << "Operation failed!" << std::endl;
        return 1;
    }
    
    return 0;
}

编译和测试

1. 编译

bash 复制代码 
# 使用 g++
g++ -std=c++11 lzw_compressor.cpp -o lzw_compressor

# 使用 clang++
clang++ -std=c++11 lzw_compressor.cpp -o lzw_compressor

# 使用 MSVC
cl /EHsc lzw_compressor.cpp

2. 测试

bash 复制代码 
# 1. 创建测试文件
echo "Hello, this is a test file for LZW compression algorithm. The quick brown fox jumps over the lazy dog." > test.txt

# 2. 压缩
./lzw_compressor -c test.txt test.lzw

# 3. 解压
./lzw_compressor -d test.lzw test_decompressed.txt

# 4. 验证
diff test.txt test_decompressed.txt && echo "OK: Files are identical"

3. 实际文件测试

bash 复制代码 
# 压缩大文件
./lzw_compressor -c large_file.bin large_file.lzw

# 解压
./lzw_compressor -d large_file.lzw restored_file.bin

参考代码 C++写的LZW压缩算法源代码 www.youwenfan.com/contentcst/122333.html

压缩示例

复制代码 
原始文件大小: 100 bytes
压缩后大小: 65 bytes
压缩率: 35%

原始文件: "TOBEORNOTTOBEORTOBEORNOT"
压缩码字: 256 84 79 66 69 79 82 78 79 84 258 262 264 265 257

功能特点

  1. 完整的文件压缩/解压 - 支持任意二进制文件
  2. 12位固定码长 - 字典大小 4096
  3. 文件头验证 - 防止误操作
  4. 错误处理 - 完善的错误检查和报告
  5. 压缩率显示 - 实时显示压缩效果
  6. 内存高效 - 流式处理，不加载整个文件到内存

文件格式

复制代码 
| 偏移 | 长度 | 内容         | 描述               |
|------|------|--------------|--------------------|
| 0    | 4    | "LZW "       | 魔数标识           |
| 4    | 8    | file_size    | 原始文件大小(字节) |
| 12   | ...  | 压缩数据      | 12位编码的LZW码流  |
相关推荐
1candobetter1 小时前
JAVA后端开发——多模块项目重命名体系解析
java·开发语言·intellij-idea
citi1 小时前
OpenViking 本地搭建指南
开发语言·python·ai
AI玫瑰助手2 小时前
Python基础：列表的切片与嵌套列表使用技巧
android·开发语言·python
Bat U2 小时前
JavaEE|多线程(四)
java·开发语言
白日梦想家6812 小时前
实战避坑+性能对比，for与each循环选型指南
开发语言·前端·javascript
sycmancia2 小时前
Qt——文本编辑器中的数据存取
开发语言·qt
王老师青少年编程2 小时前
csp信奥赛C++高频考点专项训练之贪心算法 --【排序贪心】：加工生产调度
c++·算法·贪心·csp·信奥赛·排序贪心·加工生产调度
小菜鸡桃蛋狗2 小时前
C++——vector
开发语言·c++·算法
wicb91wJ62 小时前
手写一个Promise，彻底掌握异步原理
开发语言·前端·javascript
热门推荐
012026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元02GitHub 镜像站点032026年4月AI大事件深度解读：大模型竞争进入“深水区“04近期有什么ai的新消息，新动态？ 2026.4月052026 年 AI 编程助手全面对比评测：Cursor vs Copilot vs Claude Code vs GitHub Copilot Free06AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析07codex app每次打开重连5次Reconnecting问题解决08CC-Switch & Claude 基于 Linux 服务器安装使用指南09从限购到畅通：GLM-5.1 Coding Plan接入攻略102026年AI前瞻：量子AI、具身智能与科学发现的新纪元