zlib压缩解压文件

已于 2024-09-03 13:35:20 修改
阅读量415 收藏
点赞数 3
分类专栏： Win32 C++ Windows 文章标签： Win32 C++ zlib
于 2024-09-03 13:35:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flame_Cyclone/article/details/141858130
版权
Win32 同时被 3 个专栏收录
64 篇文章 1 订阅
订阅专栏
C++
54 篇文章 0 订阅
订阅专栏
Windows
32 篇文章 0 订阅
订阅专栏

zlib_utils.h

#pragma once

#include <Windows.h>
#include <tchar.h>

// 压缩文件
BOOL CompressFile(
    LPCTSTR lpSrcFileName,                  // 输入文件
    LPCTSTR lpDestFileName                  // 输出文件
);

// 解压缩文件
BOOL UncompressFile(
    LPCTSTR lpSrcFileName,                  // 输入文件
    LPCTSTR lpDestFileName                  // 输出文件
);

// 压缩文件
BOOL compress_file(
    LPCTSTR lpSrcFileName,                  // 输入文件
    LPCTSTR lpDestFileName                  // 输出文件
);

// 解压缩文件
BOOL uncompress_file(
    LPCTSTR lpSrcFileName,                  // 输入文件
    LPCTSTR lpDestFileName                  // 输出文件
);

zlib_utils.c

#include "zlib_utils.h"
#include <errno.h>
#include <malloc.h>

#define ZLIB_WINAPI
#ifdef __cplusplus
extern "C"
{
#endif

#include "zlib.h"

#ifdef __cplusplus
}
#endif

// 数据块标识
#define ZDF_HEADER_FLAG                     (0x0046445A)

// 单次压缩数据块大小
#define ZDF_BLOCK_SIZE                      (1024 * 1024 * 4)

// 数据块信息结构
typedef struct _ZDF_HEADER
{
    DWORD dwFlag;                           //块标识
    DWORD dwCheckSum;                       //块校验码
    DWORD dwDataSize;                       //压缩后数据大小
    DWORD dwRawDataSize;                    //压缩前数据大小
}ZDF_HEADER;

BOOL CompressFile(
    LPCTSTR lpSrcFileName,                  // 输入文件
    LPCTSTR lpDestFileName                  // 输出文件
)
{
    HANDLE hDestFile = INVALID_HANDLE_VALUE;
    HANDLE hSrcFile = INVALID_HANDLE_VALUE;
    LPVOID lpOutputBuf = NULL;
    LPVOID lpInputBuf = NULL;
    BOOL fResult = FALSE;

    do
    {
        DWORD dwInputBufSize = ZDF_BLOCK_SIZE;               // 读取块大小
        DWORD dwOutputBufSize = dwInputBufSize * 2;             // 输出块设为输入块2倍

        // 分配缓冲
        lpInputBuf = HeapAlloc(GetProcessHeap(), 0, dwInputBufSize);
        if (NULL == lpInputBuf)
        {
            break;
        }

        // 分配缓冲
        lpOutputBuf = HeapAlloc(GetProcessHeap(), 0, dwOutputBufSize);
        if (NULL == lpOutputBuf)
        {
            break;
        }

        // 打开输入文件
        hSrcFile = CreateFile(lpSrcFileName,
            GENERIC_READ,
            FILE_SHARE_READ,
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            NULL);

        if (INVALID_HANDLE_VALUE == hSrcFile)
        {
            break;
        }

        // 打开输出文件
        hDestFile = CreateFile(lpDestFileName,
            GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ,
            NULL,
            CREATE_ALWAYS,
            FILE_ATTRIBUTE_NORMAL,
            NULL);

        if (INVALID_HANDLE_VALUE == hDestFile)
        {
            break;
        }

        DWORD dwRead = 0;
        DWORD dwWritten = 0;
        int nResult = 0;
        while (TRUE)
        {
            // 读取输入数据
            if (!ReadFile(hSrcFile, lpInputBuf, dwInputBufSize, &dwRead, NULL))
            {
                nResult = Z_ERRNO;
                break;
            }

            // 文件读取完毕退出循环
            if (0 == dwRead)
            {
                break;
            }

            // 压缩数据块
            DWORD dwOutCompressSize = dwOutputBufSize;
            nResult = compress2((Bytef*)lpOutputBuf, &dwOutCompressSize, (Bytef*)lpInputBuf, dwRead, Z_DEFAULT_COMPRESSION);
            if (Z_OK != nResult)
            {
                break;
            }

            // 填充块信息
            ZDF_HEADER zdf = { 0 };
            zdf.dwFlag = ZDF_HEADER_FLAG;
            zdf.dwRawDataSize = dwRead;
            zdf.dwDataSize = dwOutCompressSize;
            zdf.dwCheckSum = zdf.dwFlag + zdf.dwRawDataSize + zdf.dwDataSize;

            // 写入块信息
            if (FALSE == WriteFile(hDestFile, &zdf, sizeof(zdf), &dwWritten, NULL))
            {
                nResult = Z_ERRNO;
                break;
            }

            // 写入压缩数据
            if (FALSE == WriteFile(hDestFile, lpOutputBuf, dwOutCompressSize, &dwWritten, NULL))
            {
                nResult = Z_ERRNO;
                break;
            }
        }

        if (0 != nResult)
        {
            break;
        }

        fResult = TRUE;

    } while (FALSE);

    if (NULL != lpOutputBuf)
    {
        HeapFree(GetProcessHeap(), 0, lpOutputBuf);
    }

    if (NULL != lpInputBuf)
    {
        HeapFree(GetProcessHeap(), 0, lpInputBuf);
    }

    if (INVALID_HANDLE_VALUE != hSrcFile)
    {
        CloseHandle(hSrcFile);
    }

    if (INVALID_HANDLE_VALUE != hDestFile)
    {
        CloseHandle(hDestFile);
    }

    // 失败则删除输出文件
    if (FALSE == fResult)
    {
        DeleteFile(lpDestFileName);
    }

    return fResult;
}

BOOL UncompressFile(
    LPCTSTR lpSrcFileName,                  // 输入文件
    LPCTSTR lpDestFileName                  // 输出文件
)
{
    HANDLE hDestFile = INVALID_HANDLE_VALUE;
    HANDLE hSrcFile = INVALID_HANDLE_VALUE;
    LPVOID lpOutputBuf = NULL;
    LPVOID lpInputBuf = NULL;
    BOOL fResult = FALSE;

    do
    {
        DWORD dwInputBufSize = ZDF_BLOCK_SIZE;           // 读取块大小
        DWORD dwOutputBufSize = dwInputBufSize * 2;         // 输出块设为输入块2倍

        // 分配输入缓冲
        lpInputBuf = HeapAlloc(GetProcessHeap(), 0, dwInputBufSize);
        if (NULL == lpInputBuf)
        {
            break;
        }

        // 分配输出缓冲
        lpOutputBuf = HeapAlloc(GetProcessHeap(), 0, dwOutputBufSize);
        if (NULL == lpOutputBuf)
        {
            break;
        }

        // 打开输入文件
        hSrcFile = CreateFile(lpSrcFileName,
            GENERIC_READ,
            FILE_SHARE_READ,
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            NULL);

        if (INVALID_HANDLE_VALUE == hSrcFile)
        {
            break;
        }

        // 打开输出文件
        hDestFile = CreateFile(lpDestFileName,
            GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ,
            NULL,
            CREATE_ALWAYS,
            FILE_ATTRIBUTE_NORMAL,
            NULL);

        if (INVALID_HANDLE_VALUE == hDestFile)
        {
            break;
        }

        DWORD dwRead = 0;
        DWORD dwWritten = 0;
        int nResult = 0;
        while (TRUE)
        {
            ZDF_HEADER zdf = { 0 };

            // 读取压缩块大小
            if (!ReadFile(hSrcFile, &zdf, sizeof(zdf), &dwRead, NULL))
            {
                break;
            }

            // 文件读取完毕退出循环
            if (0 == dwRead)
            {
                break;
            }

            //检查块信息
            if (zdf.dwCheckSum != (zdf.dwFlag + zdf.dwRawDataSize + zdf.dwDataSize))
            {
                nResult = Z_ERRNO;
                break;
            }

            // 扩充输入缓冲(默认缓冲不够时)
            if (zdf.dwDataSize > dwInputBufSize)
            {
                // 释放旧缓冲
                if (FALSE == HeapFree(GetProcessHeap(), 0, lpInputBuf))
                {
                    nResult = Z_ERRNO;
                    break;
                }

                // 分配新缓冲
                dwInputBufSize = zdf.dwDataSize;
                lpInputBuf = HeapAlloc(GetProcessHeap(), 0, dwInputBufSize);
                if (NULL == lpInputBuf)
                {
                    nResult = Z_ERRNO;
                    break;
                }
            }

            // 扩充输出缓冲(默认缓冲不够时)
            if (zdf.dwRawDataSize > dwOutputBufSize)
            {
                // 释放旧缓冲
                if (FALSE == HeapFree(GetProcessHeap(), 0, lpOutputBuf))
                {
                    nResult = Z_ERRNO;
                    break;
                }

                // 分配新缓冲
                dwOutputBufSize = zdf.dwRawDataSize;
                lpOutputBuf = HeapAlloc(GetProcessHeap(), 0, dwOutputBufSize);
                if (NULL == lpOutputBuf)
                {
                    nResult = Z_ERRNO;
                    break;
                }
            }

            // 读取压缩块
            if (!ReadFile(hSrcFile, lpInputBuf, zdf.dwDataSize, &dwRead, NULL))
            {
                break;
            }

            // 解压数据块
            DWORD dwOutCompressSize = dwOutputBufSize;
            nResult = uncompress((Bytef*)lpOutputBuf, &dwOutCompressSize, (Bytef*)lpInputBuf, dwRead);
            if (Z_OK != nResult)
            {
                break;
            }

            // 输出到文件
            if (!WriteFile(hDestFile, lpOutputBuf, dwOutCompressSize, &dwWritten, NULL))
            {
                nResult = Z_ERRNO;
                break;
            }
        }

        if (0 != nResult)
        {
            break;
        }

        fResult = TRUE;

    } while (FALSE);

    if (NULL != lpInputBuf)
    {
        HeapFree(GetProcessHeap(), 0, lpInputBuf);
    }

    if (NULL != lpOutputBuf)
    {
        HeapFree(GetProcessHeap(), 0, lpOutputBuf);
    }

    if (INVALID_HANDLE_VALUE != hSrcFile)
    {
        CloseHandle(hSrcFile);
    }

    if (INVALID_HANDLE_VALUE != hDestFile)
    {
        CloseHandle(hDestFile);
    }

    // 失败则删除输出文件
    if (FALSE == fResult)
    {
        DeleteFile(lpDestFileName);
    }

    return fResult;
}

BOOL compress_file(
    LPCTSTR lpSrcFileName,                  // 输入文件
    LPCTSTR lpDestFileName                  // 输出文件
)
{
    FILE* hSrcFile = NULL;
    FILE* hDestFile = NULL;
    void* lpOutputBuf = NULL;
    void* lpInputBuf = NULL;
    BOOL fResult = FALSE;

    do
    {
        size_t dwInputBufSize = ZDF_BLOCK_SIZE;             // 读取块大小
        size_t nOutputBufSize = dwInputBufSize * 2;        // 输出块设为输入块2倍
        errno_t err = 0;

        // 分配缓冲
        lpInputBuf = malloc(dwInputBufSize);
        if (NULL == lpInputBuf)
        {
            break;
        }

        // 分配缓冲
        lpOutputBuf = malloc(nOutputBufSize);
        if (NULL == lpOutputBuf)
        {
            break;
        }

        err = _tfopen_s(&hSrcFile, lpSrcFileName, _T("rb"));
        if (0 != err)
        {
            break;
        }

        err = _tfopen_s(&hDestFile, lpDestFileName, _T("wb"));
        if (0 != err)
        {
            break;
        }

        size_t nReadSize = 0;
        size_t nWritten = 0;
        int nResult = 0;
        while (TRUE)
        {
            size_t nReadReady = dwInputBufSize;

            // 读取输入数据
            nReadSize = fread_s(lpInputBuf, dwInputBufSize, 1, nReadReady, hSrcFile);
            // 文件读取完毕退出循环
            if (0 == nReadSize)
            {
                break;
            }

            if (0 != ferror(hSrcFile))
            {
                break;
            }

            // 压缩数据块
            size_t nOutCompressSize = nOutputBufSize;
            nResult = compress2((Bytef*)lpOutputBuf, &nOutCompressSize, (Bytef*)lpInputBuf, nReadSize, Z_DEFAULT_COMPRESSION);
            if (Z_OK != nResult)
            {
                break;
            }

            // 填充块信息
            ZDF_HEADER zdf = { 0 };
            zdf.dwFlag = ZDF_HEADER_FLAG;
            zdf.dwRawDataSize = nReadSize;
            zdf.dwDataSize = nOutCompressSize;
            zdf.dwCheckSum = zdf.dwFlag + zdf.dwRawDataSize + zdf.dwDataSize;

            if (0 == fwrite(&zdf, sizeof(zdf), 1, hDestFile))
            {
                break;
            }


            if (nOutCompressSize != fwrite(lpOutputBuf, 1, nOutCompressSize, hDestFile))
            {
                break;
            }
        }

        if (0 != nResult)
        {
            break;
        }

        fResult = TRUE;

    } while (FALSE);

    if (NULL != lpOutputBuf)
    {
        free(lpOutputBuf);
    }

    if (NULL != lpInputBuf)
    {
        free(lpInputBuf);
    }

    if (NULL != hSrcFile)
    {
        fclose(hSrcFile);
    }

    if (NULL != hDestFile)
    {
        fclose(hDestFile);
    }

    // 失败则删除输出文件
    if (FALSE == fResult)
    {
        _tremove(lpDestFileName);
    }

    return fResult;
}

BOOL uncompress_file(
    LPCTSTR lpSrcFileName,                  // 输入文件
    LPCTSTR lpDestFileName                  // 输出文件
)
{
    FILE* hSrcFile = NULL;
    FILE* hDestFile = NULL;
    void* lpOutputBuf = NULL;
    void* lpInputBuf = NULL;
    BOOL fResult = FALSE;
    do
    {
        size_t nInputBufSize = ZDF_BLOCK_SIZE;               // 读取块大小
        size_t nOutputBufSize = nInputBufSize * 2;             // 输出块设为输入块2倍
        errno_t err = 0;

        // 分配缓冲
        lpInputBuf = malloc(nInputBufSize);
        if (NULL == lpInputBuf)
        {
            break;
        }

        // 分配缓冲
        lpOutputBuf = malloc(nOutputBufSize);
        if (NULL == lpOutputBuf)
        {
            break;
        }

        err = _tfopen_s(&hSrcFile, lpSrcFileName, _T("rb"));
        if (0 != err)
        {
            break;
        }

        err = _tfopen_s(&hDestFile, lpDestFileName, _T("wb"));
        if (0 != err)
        {
            break;
        }

        size_t nWritten = 0;
        int nResult = 0;
        while (TRUE)
        {
            ZDF_HEADER zdf = { 0 };
            size_t nReadSize = 0;

            // 读取压缩块大小
            nReadSize = fread_s(&zdf, sizeof(zdf), 1, sizeof(zdf), hSrcFile);
            if (0 == nReadSize)
            {
                break;
            }

            if (0 != ferror(hSrcFile))
            {
                break;
            }

            //检查块信息
            if (zdf.dwCheckSum != (zdf.dwFlag + zdf.dwRawDataSize + zdf.dwDataSize))
            {
                nResult = Z_ERRNO;
                break;
            }

            // 扩充输入缓冲(默认缓冲不够时)
            if (zdf.dwDataSize > nInputBufSize)
            {
                // 释放旧缓冲
                free(lpInputBuf);

                // 分配新缓冲
                nInputBufSize = zdf.dwDataSize;
                lpInputBuf = malloc(nInputBufSize);
                if (NULL == lpInputBuf)
                {
                    nResult = Z_ERRNO;
                    break;
                }
            }

            // 扩充输出缓冲(默认缓冲不够时)
            if (zdf.dwRawDataSize > nOutputBufSize)
            {
                // 释放旧缓冲
                free(lpOutputBuf);

                // 分配新缓冲
                nOutputBufSize = zdf.dwRawDataSize;
                lpOutputBuf = malloc(nOutputBufSize);
                if (NULL == lpOutputBuf)
                {
                    nResult = Z_ERRNO;
                    break;
                }
            }

            // 读取压缩块
            nReadSize = fread_s(lpInputBuf, nInputBufSize, 1, zdf.dwDataSize, hSrcFile);
            if (0 == nReadSize)
            {
                break;
            }

            if (0 != ferror(hSrcFile))
            {
                break;
            }

            // 解压数据块
            DWORD nOutCompressSize = nOutputBufSize;
            nResult = uncompress((Bytef*)lpOutputBuf, &nOutCompressSize, (Bytef*)lpInputBuf, zdf.dwDataSize);
            if (Z_OK != nResult)
            {
                break;
            }

            // 输出到文件
            if (!fwrite(lpOutputBuf, nOutCompressSize, 1, hDestFile))
            {
                nResult = Z_ERRNO;
                break;
            }
        }

        if (0 != nResult)
        {
            break;
        }

        fResult = TRUE;

    } while (FALSE);

    if (NULL != lpInputBuf)
    {
        free(lpInputBuf);
    }

    if (NULL != lpOutputBuf)
    {
        free(lpOutputBuf);
    }

    if (NULL != hSrcFile)
    {
        fclose(hSrcFile);
    }

    if (NULL != hDestFile)
    {
        fclose(hDestFile);
    }

    // 失败则删除输出文件
    if (FALSE == fResult)
    {
        _tremove(lpDestFileName);
    }

    return fResult;
}

main.c

#include "zlib_utils.h"

int main()
{
    compress_file(_T("zlib_test.pdb"), _T("zlib_test.zdf"));
    uncompress_file(_T("zlib_test.zdf"), _T("zlib_test_out.pdb"));
    return 0;
}

Flame_Cyclone
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zlib压缩文件小工具
04-05
一个python写的可以对任意文件进行zlib压缩的小工具
C++ Zlib库实现zip文件压缩解压(支持递归压缩)
10-10
C++利用Zlib库实现zip文件压缩及解压 支持递归压缩.可配合自动更新功能实现zip压缩包进得软件更新
C/C++ Zlib实现文件压缩与解压
CSDN
11-28 8137
在软件开发和数据处理中，对数据进行高效的压缩和解压缩是一项重要的任务。这不仅有助于减小数据在网络传输和存储中的占用空间，还能提高系统的性能和响应速度。本文将介绍如何使用 zlib 库进行数据的压缩和解压缩，以及如何保存和读取压缩后的文件。zlib 是一个开源的数据压缩库，旨在提供高效、轻量级的压缩和解压缩算法。其核心压缩算法基于 DEFLATE，这是一种无损数据压缩算法，通常能够提供相当高的压缩比。zlib 库广泛应用于多个领域，包括网络通信、文件压缩、数据库系统等。
Zlib文件压缩和解压
kkwant的博客
08-18 1万+
开源代码： http://www.zlib.net/ zlib使用手册： http://www.zlib.net/manual.html zlib wince版： http://www.tenik.c
Qt调用zlib压缩解压文件
zhengtianzuo的博客
12-22 2723
zlib提供compress uncompress 两个函数分别是压缩和解压ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen));ZEXTERN int ZEXPORT uncomp
python使用zlib压缩和解压文件
qq_34474071的博客
03-31 2535
zlib设置压缩等级，zlib压缩等级为1-9，数值越大压缩比越高，压缩速度越慢
GNU zlib 压缩与解压文件详细介绍
Bruce小鬼
02-16 928
zlib 模块为 GNU 项目的 zlib 压缩库中的许多函数提供了一个低级接口。
使用zlib压缩多个文件
hx0318的博客
08-15 434
slFileList.append("F:/资源/ColorTest2.0_V2.5.14.221116.exe");slFileList.append("D:/公司相关/加特林新员工入职指南V2.0-230322修改1.docx");slFileList.append("D:/公司相关/C 代码规范学习资料.rar");slFileList.append("F:/资源/cs1.png");我这边用vs2017打开后直接就编译了6个文件成功了。
linux zlib文件解压_PHP的zlib压缩工具扩展包学习
weixin_39795268的博客
11-22 402
PHP的zlib压缩工具扩展包学习总算到了我们压缩相关扩展的最后一篇文章了，最后我们要学习的也是 Linux 下非常常用的一种压缩格式：.gz 的压缩扩展。作为 PHP 的自带扩展，就像 zip 一样，zlib 扩展是随着 PHP 的安装包一起发布的，所以我们在编译的时候直接加上 --with-zlib 就可以了，如果无法找到对应的软件包的话，使用 yum 安装相应的软件包即可。创建压缩...
Zlib压缩和解压
weixin_42462436的博客
12-28 3321
C++ zlib 压缩和解压
Zlib压缩解压工具
05-15
在开始使用Zlib压缩解压工具前，用户需要注意运行"reg.bat"文件。这个批处理脚本的作用是注册组件，确保系统能够识别并正确调用Zlib相关的动态链接库（DLL）文件。在Windows环境中，某些程序需要注册才能正常工作，...
C++ 使用zlib压缩和解压文件
10-16
标题"**C++使用zlib压缩和解压文件**"所涉及的核心知识点包括： 1. **C++编程**：使用C++进行文件操作，包括读取、写入和流处理。 2. **zlib库**：zlib是一个开源的压缩库，支持多种压缩和解压缩算法，如GZIP和...
C++ 基于ZLIB压缩库的数据或文件的压缩与解压缩小程序.zip
11-11
本项目“C++ 基于ZLIB压缩库的数据或文件的压缩与解压缩小程序”正是利用了ZLIB库来实现这个功能。 ZLIB库是基于DEFLATE算法的，这是一种混合了LZ77（一种字典压缩方法）和霍夫曼编码（一种熵编码方法）的高效压缩...
VC++使用zlib压缩及解压数据，使用base64编码及解码数据（附源码）
热门推荐
dvlinker的技术专栏
06-17 1万+
使用zlib压缩及解压数据，使用base64编码及解码数据。
Linux下使用zlib实现文件压缩解压
staticnetwind的专栏
04-10 6243
Linux下使用zlib实现文件压缩解压1.背景2.思路3.实现3.1 函数入口3.2 压缩文件3.3 解压文件4.运行5.结论 1.背景 上篇文章《Linux下使用zlib实现数据压缩解压》对文本数据进行压缩处理，本文再进行zlib的案例进行学习，这次整理出了文件压缩例子。 2.思路 查看 zlib-1.2.11/examples/zpipe.c代码，发现他的处理是从stdin获取原始数据，再从...
2进制3位数过去现在将来输赢公式代码.txt
09-07
2进制3位数过去现在将来输赢公式代码
福州大学在广东2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
WordPress 集网址、资源、资讯于一体的导航类主题开心版
09-07
WordPress 集网址、资源、资讯于一体的导航类主题开心版； 运行环境 PHP7.4 + MYSQL5.6
【Java学习】activemq消息中间件学习demo.zip
09-07
【Java学习】activemq消息中间件学习demo.zip 【Java学习】activemq消息中间件学习demo.zip 【Java学习】activemq消息中间件学习demo.zip
c++ zlib文件压缩解压缩
06-15
解压缩过程与压缩过程类似，需要先打开源文件和目标文件，然后调用Zlib提供的解压函数将源文件中的数据解压到目标文件中。解压完毕后，同样需要关闭源文件和目标文件。 需要注意的是，在使用Zlib进行文件压缩和解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值