文件分割合并(Win32, C++)

已于 2024-03-01 22:02:40 修改
阅读量392 收藏 8
点赞数 8
分类专栏： Win32 C++ 文章标签： C++ Win32 文件分割 文件合并
于 2024-01-04 12:47:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flame_Cyclone/article/details/135383940
版权
Win32 同时被 2 个专栏收录
59 篇文章 1 订阅
订阅专栏
C++
49 篇文章 0 订阅
订阅专栏

CFileSplitUtils.h

#pragma once
#include <vector>
#include <string>
#include <functional>

#ifdef _UNICODE
using _tstring = std::wstring;
#else
using _tstring = std::string;
#endif

typedef struct _SPLIT_DATA_INFO
{
    long long llBeginPos = 0;   //分割起始位置
    long long llEndPos = 0;     //分割结束位置
    long long llSize = 0;       //分割大小
    long long llCount = 0;      //分割数量

    _SPLIT_DATA_INFO() : llBeginPos(0), llEndPos(0), llSize(0), llCount(0)
    {
        memset(this, 0, sizeof(*this));
    }
}SPLIT_DATA_INFO;

typedef struct _SPLIT_FILE_INFO
{
    long long llBeginPos = 0;   //分割起始位置
    long long llSize = 0;       //分割大小

    _SPLIT_FILE_INFO() : llBeginPos(0), llSize(0)
    {
        memset(this, 0, sizeof(*this));
    }
}SPLIT_FILE_INFO;

class CFileSplitUtils
{
public:

    //
    // @brief: 合并文件
    // @param: fileList         文件路径字符串容器
    // @param: strFilePath      保存文件路径
    // @param: cbProgress       进度回调函数, 返回false则终止合并
    // @ret: void
    static bool CombineFile(
        const std::vector<_tstring>& fileList,
        const _tstring& strFilePath,
        std::function<bool(
            unsigned long long ullFileCount,            //已处理文件数
            unsigned long long ullFileTotal,       //总文件数
            unsigned long long ullBytesCount,           //已处理数据量
            unsigned long long ullBytesTotal       //总数据量
            )> cbProgress = nullptr
    );

    //
    // @brief: 分割文件
    // @param: strFilePath      文件路径
    // @param: strFileOutDir    保存文件夹
    // @param: strSplitCfg      分割配置字符串, 参数: 起始, 结束, 块大小, 份数
    //                              如: "0, -1, 8K, 16", 从文件头开始, 文件尾结束, 每个块8KB, 最多分割为16个文件
    // @param: strPrefixName    文件名前缀
    // @param: strExtName       文件名后缀
    // @param: nIndex           文件名起始索引
    // @param: bHexnIndex       文件名起始索引使用十六进制
    // @param: bHasRange        文件名包含数据范围
    // @param: bHasCrc32        文件名包含CRC32校验码
    // @param: cbProgress       进度回调函数, 返回false则终止合并
    // @ret: void
    static bool SplitFile(
        const _tstring& strFilePath,
        const _tstring& strFileOutDir,
        const _tstring& strSplitCfg,
        const _tstring& strPrefixName,
        const _tstring& strExtName,
        long long nIndex = 0,
        bool bHexIndex = false,
        bool bHasRange = false,
        bool bHasCrc32 = false,

        std::function<bool(
            unsigned long long ullFileCount,            //已处理文件数
            unsigned long long ullFileTotal,       //总文件数
            unsigned long long ullBytesCount,           //已处理数据量
            unsigned long long ullBytesTotal       //总数据量
            )> cbProgress = nullptr
    );

    //
    // @brief: 获取文件大小
    // @param: strFilePath      保存文件路径
    // @ret: long long          文件大小
    static long long GetFileSize(
        const _tstring& strFilePath
    );

    //
    // @brief: 从字符串解析分割信息
    // @param: strSplitCfg      分割配置字符串
    // @ret: std::vector<FILE_SPLIT_INFO>        分割信息
    static std::vector<SPLIT_DATA_INFO> GetSplitDataInfos(
        const _tstring& strSplitCfg
    );

    //
    // @brief: 从分割信息分解出分割元素
    // @param: splitInfo        分割信息
    // @param: llFileSize       文件大小
    // @ret: std::vector<SPLIT_DATA_INFO>        单个文件分割信息
    static std::vector<SPLIT_FILE_INFO> GetSpliFilenfos(
        const std::vector<SPLIT_DATA_INFO>& splitInfo,
        long long llFileSize
    );

    //
    // @brief: 从分割信息统计分割后文件总数
    // @param: splitInfo        分割信息
    // @param: llFileSize       文件大小
    // @ret: long long          分割后文件总数
    static long long GetSplitFileCount(
        const std::vector<SPLIT_DATA_INFO>& splitInfo,
        long long llFileSize
    );

    //
    // @brief: 从分割信息统计分割后数据总量
    // @param: splitInfo        分割信息
    // @param: llFileSize       文件大小
    // @ret: long long          分割后数据总量
    static long long GetSplitTotalSize(
        const std::vector<SPLIT_DATA_INFO>& splitInfo,
        long long llFileSize
    );

    //
    // @brief: 从分割信息统计分割后最大数据位置
    // @param: splitInfo        分割信息
    // @param: llFileSize       文件大小
    // @ret: long long          分割后最大数据位置
    static long long GetSplitMaxPos(
        const std::vector<SPLIT_DATA_INFO>& splitInfo,
        long long llFileSize
    );
};

CFileSplitUtils.cpp

#include "CFileSplitUtils.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fstream>
#include <tchar.h>
#include "CCrc32Utils.h"
#include "CStrUtils.h"
#include "CPathUtils.h"

long long CFileSplitUtils::GetFileSize(const _tstring& strFilePath)
{
    struct _stat64 statbuf = { 0 };
    if (0 == _tstat64(strFilePath.c_str(), &statbuf))
    {
        return statbuf.st_size;
    }

    return 0;
}

bool CFileSplitUtils::SplitFile(
    const _tstring& strFilePath,
    const _tstring& strFileOutDir,
    const _tstring& strSplitCfg,
    const _tstring& strPrefixName,
    const _tstring& strExtName,
    long long nIndex/* = 0*/,
    bool bHexIndex/* = false*/,
    bool bHasRange/* = false*/,
    bool bHasCrc32/* = false*/,
    std::function<bool(
        unsigned long long ullFileCount,            //已处理文件数
        unsigned long long ullFileTotal,       //总文件数
        unsigned long long ullBytesCount,           //已处理数据量
        unsigned long long ullBytesTotal       //总数据量
        )
    > cbProgress/* = nullptr*/
)
{
    _tstring strOutDir = strFileOutDir;
    _tstring strPrefix = strPrefixName;
    _tstring strExt = strExtName;

    //获取分割信息
    std::vector<SPLIT_DATA_INFO> vFileSplitInfos = GetSplitDataInfos(strSplitCfg);

    //获取文件大小
    long long llFileSize = GetFileSize(strFilePath);

    //统计分数数量
    long long llSplitCount = GetSplitFileCount(vFileSplitInfos, llFileSize);

    //获取最大数据位置
    long long llSplitMaxPos = GetSplitMaxPos(vFileSplitInfos, llFileSize);

    //获取文件大小
    long long llTotalSize = GetSplitTotalSize(vFileSplitInfos, llFileSize);

    //分解分割任务
    std::vector<SPLIT_FILE_INFO> vSplitInfos = GetSpliFilenfos(vFileSplitInfos, llFileSize);

    if (0 == llFileSize || 0 == llSplitCount)
    {
        return false;
    }

    std::ifstream inputFile(strFilePath, std::ios::binary | std::ios::in);
    if (!inputFile.is_open())
    {
        return false;
    }

    long long ullFileCount = 0;
    long long ullFileTotal = llSplitCount;
    long long ullBytesCount = 0;
    long long ullBytesTotal = llTotalSize;
    bool bCancel = false;

    //计算索引字符串格式
    _tstring strIndexFormat;
    if (bHexIndex)
    {
        strIndexFormat = CStrUtils::Format(_T("%%0%dX"), CStrUtils::Format(_T("%X"), llSplitCount + nIndex - 1).size());
    }
    else
    {
        strIndexFormat = CStrUtils::Format(_T("%%0%dd"), CStrUtils::Format(_T("%d"), llSplitCount + nIndex - 1).size());
    }

    //计算数据范围字符串格式
    int nRangeLength = (int)CStrUtils::Format(_T("%llX"), llSplitMaxPos).size();
    _tstring strRangeFormat = CStrUtils::Format(_T("%%0%dllX-%%0%dllX"), nRangeLength, nRangeLength);

    //前缀名检查
    if (strPrefix.empty())
    {
        strPrefix = CPathUtils::GetFileName(strFilePath, false);
    }

    //输出目录检查
    if (strOutDir.empty())
    {
        strOutDir = CPathUtils::GetFileDir(strFilePath);
        strOutDir += _T("\\");
        strOutDir += CPathUtils::GetFileName(strFilePath, false);
        strOutDir += _T("_Split");
    }

    //创建文件夹
    if (!CPathUtils::IsExist(strOutDir))
    {
        CPathUtils::CreateDir(strOutDir);
    }

    //开始分割文件
    _tstring strOutTemp = strOutDir + _T("\\Temp");

    //读写文件缓冲分配
    const size_t bufSize = static_cast<size_t>(1024 * 1024) * 4;
    char* pDataBuf = new (std::nothrow) char[bufSize];
    if (nullptr == pDataBuf)
    {
        return false;
    }

    //开始分割文件
    for (int i = 0; i < vSplitInfos.size(); i++)
    {
        SPLIT_FILE_INFO& info = vSplitInfos[i];

        std::ofstream outFile(strOutTemp, std::ios::binary | std::ios::out);
        if (!outFile.is_open())
        {
            return 0;
        }

        inputFile.seekg(info.llBeginPos, std::ios::beg);

        uint32_t uCrc32 = 0;
        long long nBlockSize = bufSize;
        long long llSize = info.llSize;

        while (llSize > 0)
        {
            if (llSize > bufSize)
            {
                nBlockSize = bufSize;
            }
            else
            {
                nBlockSize = llSize;
            }

            inputFile.read(pDataBuf, nBlockSize);
            size_t llRead = (size_t)inputFile.gcount();

            if (bHasCrc32)
            {
                uCrc32 = CCrc32Utils::GetPartCrc32(uCrc32, pDataBuf, llRead);
            }

            outFile.write(pDataBuf, llRead);
            llSize -= nBlockSize;
            ullBytesCount += llRead;

            //输出单个文件结束处理
            if (0 == llSize)
            {
                ullFileCount++;
                long long llBegin = info.llBeginPos;
                long long llEnd = info.llBeginPos + info.llSize - 1;

                _tstring strOutPath = strOutDir + _T("\\");

                //文件名前缀
                if (!strPrefix.empty())
                {
                    strOutPath += strPrefix;
                    strOutPath += _T("_");
                }

                //文件名序号
                strOutPath += CStrUtils::Format(strIndexFormat.c_str(), nIndex + i);

                //文件名添加数据范围
                if (bHasRange)
                {
                    _tstring strRange = CStrUtils::Format(strRangeFormat.c_str(), llBegin, llEnd);
                    strOutPath += _T("_");
                    strOutPath += strRange;
                }

                //文件名添加CRC32校验码
                if (bHasCrc32)
                {
                    strOutPath += _T("_");
                    strOutPath += CCrc32Utils::GetStrFromValue(uCrc32, true);
                }

                //文件名添加扩展名
                if (!strExt.empty())
                {
                    strOutPath += _T(".");
                    strOutPath += strExt;
                }

                outFile.close();

                //删除文件, 防止影响重命名失败
                CPathUtils::DeleteArchive(strOutPath);

                //临时文件重命名
                CPathUtils::Rename(strOutTemp, strOutPath);
            }

            //回调检查
            if (nullptr == cbProgress)
            {
                continue;
            }

            //回调返回false则停止合并文件
            if (!cbProgress(ullFileCount, ullFileTotal, ullBytesCount, ullBytesTotal))
            {
                outFile.close();

                //中断则删除临时文件
                CPathUtils::Delete(strOutTemp);
                bCancel = true;
                break;
            }
        }
    }

    if (nullptr != pDataBuf)
    {
        delete[]pDataBuf;
        pDataBuf = nullptr;
    }

    return true;
}

bool CFileSplitUtils::CombineFile(
    const std::vector<_tstring>& fileList,
    const _tstring& strFilePath,
    std::function<bool(
        unsigned long long ullFileCount,            //已处理文件数
        unsigned long long ullFileTotal,       //总文件数
        unsigned long long ullBytesCount,           //已处理数据量
        unsigned long long ullBytesTotal       //总数据量
        )
    > cbProgress/* = nullptr*/
)
{
    const size_t bufSize = static_cast<size_t>(1024 * 1024) * 4;
    char* pDataBuf = new (std::nothrow) char[bufSize];
    if (nullptr == pDataBuf)
    {
        return false;
    }

    long long ullFileCount = 0;
    long long ullTotalFileCount = 0;
    long long ullBytesCount = 0;
    long long ullTotalBytesCount = 0;
    bool bCancel = false;

    //打开输出文件
    std::ofstream outFile(strFilePath, std::ios::binary | std::ios::out);
    if (!outFile.is_open())
    {
        return false;
    }

    //统计文件数量与数据量
    for (const auto& item : fileList)
    {
        long long llFileSize = GetFileSize(item);
        if (-1 != llFileSize)
        {
            ullTotalBytesCount += llFileSize;
            ullTotalFileCount++;
        }
    }

    //开始将文件合并输出
    for (const auto& item : fileList)
    {
        //打开文件
        std::ifstream inputFile(item, std::ios::binary | std::ios::in);
        if (!inputFile.is_open())
        {
            continue;
        }

        //块大小
        long long nBlockSize = bufSize;

        //文件大小
        long long llSize = GetFileSize(item);

        while (llSize > 0)
        {
            if (llSize > bufSize)
            {
                nBlockSize = bufSize;
            }
            else
            {
                nBlockSize = llSize;
            }

            inputFile.read(pDataBuf, nBlockSize);
            long long llRead = inputFile.gcount();
            outFile.write(pDataBuf, llRead);
            llSize -= nBlockSize;
            ullBytesCount += llRead;

            if (0 == llSize)
            {
                ullFileCount++;
            }

            //回调检查
            if (cbProgress)
            {
                //回调返回false则停止合并文件
                if (!cbProgress(ullFileCount, ullTotalFileCount, ullBytesCount, ullTotalBytesCount))
                {
                    bCancel = true;
                    break;
                }
            }
        }

        inputFile.close();

        if (bCancel)
        {
            break;
        }
    }

    //善后处理
    if (nullptr != pDataBuf)
    {
        delete[]pDataBuf;
        pDataBuf = nullptr;
    }

    outFile.close();

    return true;
}

std::vector<SPLIT_DATA_INFO> CFileSplitUtils::GetSplitDataInfos(
    const _tstring& strSplitCfg
)
{
    std::vector<SPLIT_DATA_INFO> infos;

    //解析分割范围
    _tstring strSplitList = strSplitCfg;

    CStrUtils::Replace(strSplitList, _T(" "), _T(""), false);
    std::vector<_tstring> vSplitList = CStrUtils::SplitStr(strSplitList, _T("\r\n"));

    for (const auto& lineItem : vSplitList)
    {
        //开头 ; 认为是注释, 忽略不管
        if (_T(';') == lineItem.front())
        {
            continue;
        }

        //拆分子项
        std::vector<_tstring> vSplitItem = CStrUtils::SplitStr(lineItem, _T(";"));
        for (const auto& subItem : vSplitItem)
        {
            long long llValues[4] = { 0, -1, 0, 0 };

            std::vector<_tstring> vSplitValue = CStrUtils::SplitStr(subItem, _T(","));
            for (int i = 0; i < (int)vSplitValue.size(); i++)
            {
                if (i >= _countof(llValues))
                {
                    break;
                }

                _tstring strHex = _T("0x");
                _tstring strNegative = _T("-");
                bool bNegative = false;

                TCHAR* pEndChar = nullptr;

                _tstring itemValue = vSplitValue[i];

                if (0 == CStrUtils::FindSubString(itemValue, strNegative))
                {
                    bNegative = true;
                    itemValue = itemValue.substr(1, (size_t)-1);
                }

                if (0 == CStrUtils::FindSubString(itemValue, strHex))
                {
                    llValues[i] = _tcstoll(itemValue.c_str(), &pEndChar, 16);
                }
                else
                {
                    llValues[i] = _tcstoll(itemValue.c_str(), &pEndChar, 10);
                }

                if (nullptr != pEndChar)
                {
                    if (_T('K') == *pEndChar || _T('k') == *pEndChar)
                    {
                        llValues[i] *= 1024;
                    }
                    if (_T('M') == *pEndChar || _T('m') == *pEndChar)
                    {
                        llValues[i] *= 1024 * 1024;
                    }
                    if (_T('G') == *pEndChar || _T('g') == *pEndChar)
                    {
                        llValues[i] *= 1024 * 1024 * 1024;
                    }
                }

                if (bNegative)
                {
                    llValues[i] = 0 - llValues[i];
                }
            }

            SPLIT_DATA_INFO info;
            info.llBeginPos = llValues[0];
            info.llEndPos = llValues[1];
            info.llSize = llValues[2];
            info.llCount = llValues[3];

            infos.push_back(info);
        }
    }

    return infos;
}

long long CFileSplitUtils::GetSplitFileCount(
    const std::vector<SPLIT_DATA_INFO>& splitInfo,
    long long llFileSize
)
{
    long long llSplitCopunt = 0;

    for (const auto& item : splitInfo)
    {
        long long llBeginPos = item.llBeginPos;
        long long llEndPos = item.llEndPos;
        long long llSize = item.llSize;
        long long llCount = item.llCount;

        //结束位置
        if (item.llEndPos < 0)
        {
            llEndPos = llFileSize + item.llEndPos;
        }

        //最大结束位置不得超过文件末尾
        if (item.llEndPos >= llFileSize)
        {
            llEndPos = llFileSize - 1;
        }

        //确定起始位置
        if (item.llBeginPos < 0)
        {
            llBeginPos = llFileSize + item.llBeginPos;
        }

        //起始位置大小排序
        if (llEndPos < llBeginPos)
        {
            long long llTemp = llBeginPos;
            llBeginPos = llEndPos;
            llEndPos = llTemp;
        }

        //起始位置必须位于文件范围内
        if (llBeginPos < 0 || llBeginPos >= llFileSize || llEndPos < 0 || llEndPos >= llFileSize)
        {
            continue;
        }

        if (llCount < 0)//文件分割个数不能为负数
        {
            continue;
        }

        //未指定数量, 则认为是分割为1个文件
        if (0 == llCount)
        {
            if (0 == llSize)
            {
                llCount = 1;
            }
            else
            {
                llCount = llFileSize;
            }
        }

        if (0 == llSize)//大小为0, 则按照个数平均分割
        {
            if (llCount <= 1)
            {
                llCount = 1;
            }

            //统计分割大小
            long long packSize = 0;
            packSize = (llEndPos - llBeginPos + 1) / llCount;
            if (0 != (llEndPos - llBeginPos + 1) % llCount)
            {
                packSize++;
            }

            //最多分割个数
            llCount = (llEndPos - llBeginPos + 1) / packSize;
            if (0 != (llEndPos - llBeginPos + 1) % packSize)
            {
                llCount++;
            }

            //文件个数比实际数据还大, 则按照一个字节分割
            if (llEndPos - llBeginPos + 1 < llCount)
            {
                packSize = 1;
                llCount = llEndPos - llBeginPos + 1;
            }

            llSplitCopunt += llCount;
        }
        else if (llSize < 0)//从文件末尾向文件头部分割
        {
            llSize = abs(llSize);

            //大小限定为文件大小
            if (abs(llSize) > llFileSize)
            {
                llSize = llFileSize;
            }

            long long llMaxSplitCount = (llEndPos - llBeginPos + 1) / llSize;
            if (0 != (llEndPos - llBeginPos + 1) % llSize)
            {
                llMaxSplitCount++;
            }

            if (llCount > llMaxSplitCount)
            {
                llCount = llMaxSplitCount;
            }

            llSplitCopunt += llCount;
        }
        else if (llSize > 0)//从文件头部向文件末尾分割
        {
            //大小限定为文件大小
            if (abs(llSize) > llFileSize)
            {
                llSize = llFileSize;
            }

            long long llMaxSplitCount = (llEndPos - llBeginPos + 1) / llSize;
            if (0 != (llEndPos - llBeginPos + 1) % llSize)
            {
                llMaxSplitCount++;
            }

            if (llCount > llMaxSplitCount)
            {
                llCount = llMaxSplitCount;
            }

            llSplitCopunt += llCount;
        }
    }

    return llSplitCopunt;
}

long long CFileSplitUtils::GetSplitMaxPos(
    const std::vector<SPLIT_DATA_INFO>& splitInfo,
    long long llFileSize
)
{
    long long llSplitMaxPos = 0;

    for (const auto& item : splitInfo)
    {
        long long llBeginPos = item.llBeginPos;
        long long llEndPos = item.llEndPos;
        long long llSize = item.llSize;
        long long llCount = item.llCount;

        //结束位置
        if (item.llEndPos < 0)
        {
            llEndPos = llFileSize + item.llEndPos;
        }

        //最大结束位置不得超过文件末尾
        if (item.llEndPos >= llFileSize)
        {
            llEndPos = llFileSize - 1;
        }

        //确定起始位置
        if (item.llBeginPos < 0)
        {
            llBeginPos = llFileSize + item.llBeginPos;
        }

        //起始位置大小排序
        if (llEndPos < llBeginPos)
        {
            long long llTemp = llBeginPos;
            llBeginPos = llEndPos;
            llEndPos = llTemp;
        }

        //起始位置必须位于文件范围内
        if (llBeginPos < 0 || llBeginPos >= llFileSize || llEndPos < 0 || llEndPos >= llFileSize)
        {
            continue;
        }

        if (llCount < 0)//文件分割个数不能为负数
        {
            continue;
        }

        //未指定数量, 则认为是分割为1个文件
        if (0 == llCount)
        {
            if (0 == llSize)
            {
                llCount = 1;
            }
            else
            {
                llCount = llFileSize;
            }
        }

        if (llSize <= 0)//大小为0, 则按照个数平均分割
        {
            llSplitMaxPos = llEndPos;
        }
        else if (llSize > 0)//从文件头部向文件末尾分割
        {
            //大小限定为文件大小
            if (abs(llSize) > llFileSize)
            {
                llSize = llFileSize;
            }

            long long llMaxSplitCount = (llEndPos - llBeginPos + 1) / llSize;
            if (0 != (llEndPos - llBeginPos + 1) % llSize)
            {
                llMaxSplitCount++;
            }

            if (llCount > llMaxSplitCount)
            {
                llCount = llMaxSplitCount;
            }

            long long llMaxSplitSize = llCount * llSize;
            if (llMaxSplitSize > (llEndPos - llBeginPos + 1))
            {
                llSplitMaxPos = llEndPos;
            }
            else
            {
                llSplitMaxPos = llBeginPos + llCount * llSize - 1;
            }
        }

    }

    return llSplitMaxPos;
}

long long CFileSplitUtils::GetSplitTotalSize(
    const std::vector<SPLIT_DATA_INFO>& splitInfo,
    long long llFileSize
)
{
    long long llSplitSize = 0;

    for (const auto& item : splitInfo)
    {
        long long llBeginPos = item.llBeginPos;
        long long llEndPos = item.llEndPos;
        long long llSize = item.llSize;
        long long llCount = item.llCount;

        //结束位置
        if (item.llEndPos < 0)
        {
            llEndPos = llFileSize + item.llEndPos;
        }

        //最大结束位置不得超过文件末尾
        if (item.llEndPos >= llFileSize)
        {
            llEndPos = llFileSize - 1;
        }

        //确定起始位置
        if (item.llBeginPos < 0)
        {
            llBeginPos = llFileSize + item.llBeginPos;
        }

        //起始位置大小排序
        if (llEndPos < llBeginPos)
        {
            long long llTemp = llBeginPos;
            llBeginPos = llEndPos;
            llEndPos = llTemp;
        }

        //起始位置必须位于文件范围内
        if (llBeginPos < 0 || llBeginPos >= llFileSize || llEndPos < 0 || llEndPos >= llFileSize)
        {
            continue;
        }

        if (llCount < 0)//文件分割个数不能为负数
        {
            continue;
        }

        //未指定数量, 则认为是分割为1个文件
        if (0 == llCount)
        {
            if (0 == llSize)
            {
                llCount = 1;
            }
            else
            {
                llCount = llFileSize;
            }
        }

        if (0 == llSize)//大小为0, 则按照个数平均分割
        {
            if (llCount <= 1)
            {
                llCount = 1;
            }

            //统计分割大小
            long long packSize = 0;
            packSize = (llEndPos - llBeginPos + 1) / llCount;
            if (0 != (llEndPos - llBeginPos + 1) % llCount)
            {
                packSize++;
            }

            //最多分割个数
            llCount = (llEndPos - llBeginPos + 1) / packSize;
            if (0 != (llEndPos - llBeginPos + 1) % packSize)
            {
                llCount++;
            }

            //文件个数比实际数据还大, 则按照一个字节分割
            if (llEndPos - llBeginPos + 1 < llCount)
            {
                packSize = 1;
                llCount = llEndPos - llBeginPos + 1;
            }

            long long llMaxSplitSize = llCount * packSize;
            if (llMaxSplitSize > (llEndPos - llBeginPos + 1))
            {
                llMaxSplitSize = (llEndPos - llBeginPos + 1);
            }

            llSplitSize += llMaxSplitSize;
        }
        else if (llSize < 0)//从文件末尾向文件头部分割
        {
            llSize = abs(llSize);

            //大小限定为文件大小
            if (abs(llSize) > llFileSize)
            {
                llSize = llFileSize;
            }

            long long llMaxSplitCount = (llEndPos - llBeginPos + 1) / llSize;
            if (0 != (llEndPos - llBeginPos + 1) % llSize)
            {
                llMaxSplitCount++;
            }

            if (llCount > llMaxSplitCount)
            {
                llCount = llMaxSplitCount;
            }

            long long llMaxSplitSize = llCount * llSize;
            if (llMaxSplitSize > (llEndPos - llBeginPos + 1))
            {
                llMaxSplitSize = (llEndPos - llBeginPos + 1);
            }

            llSplitSize += llMaxSplitSize;
        }
        else if (llSize > 0)//从文件头部向文件末尾分割
        {
            //大小限定为文件大小
            if (abs(llSize) > llFileSize)
            {
                llSize = llFileSize;
            }

            long long llMaxSplitCount = (llEndPos - llBeginPos + 1) / llSize;
            if (0 != (llEndPos - llBeginPos + 1) % llSize)
            {
                llMaxSplitCount++;
            }

            if (llCount > llMaxSplitCount)
            {
                llCount = llMaxSplitCount;
            }

            long long llMaxSplitSize = llCount * llSize;
            if (llMaxSplitSize > (llEndPos - llBeginPos + 1))
            {
                llMaxSplitSize = (llEndPos - llBeginPos + 1);
            }

            llSplitSize += llMaxSplitSize;
        }
    }

    return llSplitSize;
}

std::vector<SPLIT_FILE_INFO> CFileSplitUtils::GetSpliFilenfos(
    const std::vector<SPLIT_DATA_INFO>& splitInfo,
    long long llFileSize
)
{
    std::vector<SPLIT_FILE_INFO> infos;

    for (const auto& item : splitInfo)
    {
        long long llBeginPos = item.llBeginPos;
        long long llEndPos = item.llEndPos;
        long long llSize = item.llSize;
        long long llCount = item.llCount;

        //结束位置
        if (item.llEndPos < 0)
        {
            llEndPos = llFileSize + item.llEndPos;
        }

        //最大结束位置不得超过文件末尾
        if (item.llEndPos >= llFileSize)
        {
            llEndPos = llFileSize - 1;
        }

        //确定起始位置
        if (item.llBeginPos < 0)
        {
            llBeginPos = llFileSize + item.llBeginPos;
        }

        //起始位置大小排序
        if (llEndPos < llBeginPos)
        {
            long long llTemp = llBeginPos;
            llBeginPos = llEndPos;
            llEndPos = llTemp;
        }

        //起始位置必须位于文件范围内
        if (llBeginPos < 0 || llBeginPos >= llFileSize || llEndPos < 0 || llEndPos >= llFileSize)
        {
            continue;
        }

        if (llCount < 0)//文件分割个数不能为负数
        {
            llCount = 0;
        }

        //未指定数量, 则认为是分割为1个文件
        if (0 == llCount)
        {
            if (0 == llSize)
            {
                llCount = 1;
            }
            else
            {
                llCount = llFileSize;
            }
        }

        if (0 == llSize)//大小为0, 则按照个数平均分割
        {
            if (llCount <= 1)
            {
                llCount = 1;
            }

            //统计分割大小
            long long packSize = 0;
            packSize = (llEndPos - llBeginPos + 1) / llCount;
            if (0 != (llEndPos - llBeginPos + 1) % llCount)
            {
                packSize++;
            }

            //最多分割个数
            llCount = (llEndPos - llBeginPos + 1) / packSize;
            if (0 != (llEndPos - llBeginPos + 1) % packSize)
            {
                llCount++;
            }

            //文件个数比实际数据还大, 则按照一个字节分割
            if (llEndPos - llBeginPos + 1 < llCount)
            {
                packSize = 1;
                llCount = llEndPos - llBeginPos + 1;
            }

            //平均分配
            for (int i = 0; i < llCount; i++)
            {
                SPLIT_FILE_INFO info;
                info.llBeginPos = llBeginPos + i * packSize;
                info.llSize = packSize;

                //超限处理
                if ((info.llBeginPos + info.llSize - 1) > llEndPos)
                {
                    info.llSize = llEndPos - info.llBeginPos + 1;
                }

                infos.push_back(info);
            }
        }
        else if (llSize < 0)//从文件末尾向文件头部分割
        {
            llSize = abs(llSize);

            //大小限定为文件大小
            if (abs(llSize) > llFileSize)
            {
                llSize = llFileSize;
            }

            //最大分割数量
            long long llMaxSplitCount = (llEndPos - llBeginPos + 1) / llSize;
            if (0 != (llEndPos - llBeginPos + 1) % llSize)
            {
                llMaxSplitCount++;
            }

            if (llCount > llMaxSplitCount)
            {
                llCount = llMaxSplitCount;
            }

            for (int i = 0; i < llCount; i++)
            {
                SPLIT_FILE_INFO info;
                info.llSize = llSize;
                info.llBeginPos = llEndPos - ((i + 1) * llSize) + 1;

                //越界处理
                if (info.llBeginPos + info.llSize < llBeginPos)
                {
                    break;
                }

                //越界处理
                if (info.llBeginPos < llBeginPos)
                {
                    info.llBeginPos = llBeginPos;
                    info.llSize = llEndPos - (i * llSize) + 1;
                }

                infos.push_back(info);
            }
        }
        else if (llSize > 0)//从文件头部向文件末尾分割
        {
            //大小限定为文件大小
            if (abs(llSize) > llFileSize)
            {
                llSize = llFileSize;
            }

            //最大分割数量
            long long llMaxSplitCount = (llEndPos - llBeginPos + 1) / llSize;
            if (0 != (llEndPos - llBeginPos + 1) % llSize)
            {
                llMaxSplitCount++;
            }

            if (llCount > llMaxSplitCount)
            {
                llCount = llMaxSplitCount;
            }

            for (int i = 0; i < llCount; i++)
            {
                SPLIT_FILE_INFO info;
                info.llBeginPos = llBeginPos + i * llSize;
                info.llSize = llSize;

                //越界处理
                if (info.llBeginPos > llEndPos)
                {
                    break;
                }

                //越界处理
                if ((info.llBeginPos + info.llSize - 1) > llEndPos)
                {
                    info.llSize = llEndPos - info.llBeginPos + 1;
                }

                infos.push_back(info);
            }
        }
    }

    return infos;
}

main.cpp

#include <iostream>
#include <vector>
#include <stdarg.h>
#include <tchar.h>
#include <windows.h>
#include <thread>
#include <strsafe.h>
#include "Win32Utils/CFileSplitUtils.h"
#include "Win32Utils/CPathUtils.h"

int _tmain(int argc, LPCTSTR argv[])
{
    setlocale(LC_ALL, "");

    
    CFileSplitUtils::SplitFile(
        CPathUtils::GetCurrentModulePath(),
        _T(""),
        _T("0, -1, 64K, 0"),    // 从文件头开始, 文件尾结束, 每个块8KB, 分割数量不限
        _T(""),
        _T("bin"),
        0,
        false,
        true,
        true,
        [](
            unsigned long long ullFileCount,            //已处理文件数
            unsigned long long ullTotalFileCount,       //总文件数
            unsigned long long ullBytesCount,           //已处理数据量
            unsigned long long ullTotalBytesCount       //总数据量
            
            )
        {
            printf("%0.3lf/%%, %lld/%lld, %lld/%lld\n", 
                ((double)ullBytesCount / (double)ullTotalBytesCount) * 100,
                ullFileCount, ullTotalFileCount,
                ullBytesCount, ullTotalBytesCount
            );

            return true;
        }
    );

    return 0;
}

3afe2bebe69b458386db5b6433872610.png

d798b58cabde44e2a0e9c791ab74a42c.png

 

Flame_Cyclone
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分割合并文件
01-15
// 文件合并涵数 int CFileSpltDlg::MergeMe() { CWaitCursor wait; // constructing these file objects CFile destFile; // we'll use a CFileException object to get error information CFileException ex; BYTE buffer[140000]; DWORD dwRead; UINT nCount = 140000; UINT newlen = 1400000; char buff [20]; long l = 1; CString name; CString pref; CString newpath; UpdateData(TRUE); //open file for read if (!m_path.IsEmpty()) { if (!m_SourceFile.Open(m_path, CFile::modeRead | CFile::shareDenyNone | CFile::typeBinary, &ex;)) { TCHAR szError[1024]; ex.GetErrorMessage(szError, 1024); ::AfxMessageBox(szError); m_edit.SetFocus(); m_edit.SetSel(0, -1); return 1; } //construct new name m_filename = m_path.Right((m_path.GetLength() - m_path.ReverseFind('\\')) - 1); //close file m_SourceFile.Close(); } //constuct a new path name newpath = m_path.Left(m_path.GetLength() - m_filename.GetLength()); if (!m_targetpath.IsEmpty()) { //some silly check, that could be chnged if (!m_filename.IsEmpty() && m_filename.Left(2) != _T("1_")) { ::AfxMessageBox(_T("待合并的源文件名不对..."), MB_ICONERROR); return 1; } else if(m_filename.IsEmpty()) { MessageBox(_T("请选择待合并的源文件."), _T("文件分割器"), MB_ICONEXCLAMATION); return 1; } //constuct an original file name m_filename = m_filename.Right(m_filename.GetLength() - 2); //判断选择目录未尾是否已有"\"符 if(m_targetpath.Right(1)=='\\') m_path = m_targetpath + m_filename; else m_path = m_targetpath + _T("\\") + m_filename; //create target file if (!destFile.Open(m_path, CFile::modeWrite | CFile::shareExclusive | CFile::typeBinary | CFile::modeCreate, &ex;)) { TCHAR szError[1024]; ex.GetErrorMessage(szError, 1024); ::AfxMessageBox(szError); return 0; } } else if(m_path.IsEmpty()) {//souce is not there MessageBox(_T("请选择待合并的源文件."), _T("文件分割器"), MB_ICONEXCLAMATION); return 1; } if (m_targetpath.IsEmpty()) {//target is not there MessageBox(_T("请选择合并后要保存到的目标文件夹."), _T("文件分割器"), MB_ICONEXCLAMATION); return 1; } //do merge do { //constuct a new name by dynamicly incrementing prefix pref = _ltoa(l, buff, 10); pref += _T("_"); //open file with new name if (!m_SourceFile.Open(newpath + pref + m_filename, CFile::modeRead | CFile::shareExclusive | CFile::typeBinary, &ex;)) { TCHAR szError[1024]; ex.GetErrorMessage(szError, 1024); destFile.Close(); m_path = _T(""); m_filename = _T(""); // pProgress.SetPos(0); newpath = _T(""); // m_parts = _T(""); UpdateData(FALSE); //return OK because this f_n is aborting the loop if name is not found return 0; } else //constuct a new name name = _T(newpath + pref + m_filename); do {//write into file while it size < than 1.4 MB dwRead = m_SourceFile.Read(buffer, nCount); destFile.Write(buffer, dwRead); } //while we can read from source file while (dwRead > 0); m_SourceFile.Close(); // Set the range to be 0 to 500. pProgress.SetRange(0, 500); // Set the position for (int i = 0; i < 500; i++) pProgress.SetPos(i); m_parts = _ltoa(l, buff, 10); m_parts += _T("个文件已合并"); UpdateData(FALSE); l++; UpdateWindow(); } while (l < 500);//little bit dirty solution, but you can always improve it!... return 0; } //文件分割涵数 int CFileSpltDlg::SplitMe() { CWaitCursor wait; // constructing these file objects CFile destFile; // we'll use a CFileException object to get error information CFileException ex; DWORD dwRead; UINT newlen; char buff [20]; char b [20]; long l = 1; CString name; UINT len = 0; // CGradientProgressCtrl *pProgress = (CProgressCtrl*) GetDlgItem(IDC_PROGRESS); UpdateData(TRUE); //获取文件分割后的大小，定义相对应变量数值 newlen=GetSplitFileSize(); UINT nCount = newlen/10; BYTE buffer[140000]; //open file for read //m_path contain the file path if (!m_path.IsEmpty()) { if (!m_SourceFile.Open(m_path, CFile::modeRead | CFile::shareDenyNone | CFile::typeBinary, &ex;)) { TCHAR szError[1024]; ex.GetErrorMessage(szError, 1024); ::AfxMessageBox(szError); m_edit.SetFocus(); m_edit.SetSel(0, -1); return 1; } //get file length len = m_SourceFile.GetLength(); } //too lazy to put all "hard coded" strings in string table else { MessageBox(_T("请选择待分割的源文件."), _T("文件分割器"), MB_ICONEXCLAMATION); return 1; } if (m_targetpath.IsEmpty()) { MessageBox(_T("请选择分割后保存到的目标文件夹."), _T("文件分割器"), MB_ICONEXCLAMATION); return 1; } //quick and dirty check for file size if (len < newlen) { CString length = _itoa(len, b, 10); MessageBox(_T("文件长度为 " + length + " 字节，不够指定的分割大小， 没有必要再进行分割."), _T("文件分割器"), MB_ICONEXCLAMATION); m_SourceFile.Close(); m_path = _T(""); m_filename = _T(""); UpdateData(FALSE); return 1; } //do split do { //constuct a new name dynamicly changing prefix name = _ltoa(l, buff, 10); name += _T("_"); CString newpath; //判断选择目录未尾是否已有"\"符 if(m_targetpath.Right(1)=='\\') newpath = m_targetpath; else newpath = m_targetpath + _T("\\"); if (!destFile.Open(newpath + name + m_SourceFile.GetFileName(), CFile::modeWrite | CFile::shareExclusive | CFile::typeBinary | CFile::modeCreate, &ex;)) { TCHAR szError[1024]; ex.GetErrorMessage(szError, 1024); ::AfxMessageBox(szError); m_SourceFile.Close(); return 1; } do { dwRead = m_SourceFile.Read(buffer, nCount); destFile.Write(buffer, dwRead); }//while size is less than 1.4 MB while (dwRead > 0 && destFile.GetLength() < newlen); destFile.Close(); // Set the range pProgress.SetRange(0, len /newlen*10); // Set the position pProgress.SetPos(l); m_parts = _ltoa(l , buff, 10); m_parts += _T("个文件生成"); UpdateData(FALSE); l++; UpdateWindow(); } while (dwRead > 0); // close source m_SourceFile.Close(); m_path = _T(""); m_filename = _T(""); // pProgress.SetPos(0); // m_parts = _T(""); UpdateData(FALSE); return 0; }
c++ 大文件复制+分割+合并
04-15
fileManager fw; int ch; while(true) {cout<<"-----------------------------------------------"<<endl; cout<<"1.copy 2.split 3.merg 4.quickEmptyFile 0.exit"<<endl; cout<<"------------------------------------------------"<>ch; switch(ch){ case 1: fw.copyFile("D:\\cab5.cab","D:\\cab.cab"); break; case 2: fw.splitFile("123.txt",1024*200); break; case 3: fw.mergFile("123.txt"); break; case 4: fw.quickEmptyFile("D:\\12.txt",1024*1024); break; case 0: exit(0); default : cout<<"1.copy 2.split 3.merg 4.quickEmptyFile 0.exit"<<endl; } }
C ++ 学习之分文件 实现类
wniuniu_的博客
09-01 914
当您在 C++ 中编写较大的程序时，将所有代码都放在一个文件中可能会变得混乱和不可维护。为了更好地组织代码并提高可维护性，您可以使用分文件实现（Separate Compilation）的概念。
C/C++简单实现文件分块
WINGREZ‘S BLOG
10-12 5402
C语言简单实现文件分块 模块1：分割文件 指定目标输入文件（文件名或文件路径）和分割尺寸，要求分割尺寸（单位：MB）为正整数，且范围在[MIN_SIZE, MAX_SIZE]。 分割后产生块文件，命名格式为“part_”+编号。 模块2：合并文件 指定目标输出文件（文件名或文件路径）。 顺序合并块文件。 #include&lt;stdio.h&gt; #include&lt;stdlib....
C++ 实现文件分割、合并
Melonl的博客
05-01 2270
github：https://github.com/Melonl/FileSplit 基本毫无技术含量，就是读文件并写成多个小文件，并且支持自定义分割后的文件大小，单位为KB，用来对付网盘的上传文件大小限制。对于非文本格式，分割后的文件不能正常打开。 只支持windows，因为使用了win的api来判断文件。 ...
lianbiao.rar_win32
09-14
标签“win32”提示我们这个项目可能是用C++或C语言编写的，并且利用了Win32 API，这是Windows系统提供的一组低级接口，用于创建图形用户界面、管理进程和线程、进行文件I/O等。使用Win32 API可以实现更底层的控制，...
win32参考手册需要自取
03-09
### Win32参考手册知识点概览 #### 一、C++中的Windows编程概述 - **基本概念**：介绍如何在C++中开发Windows应用程序的基本原理和技术。 - **环境搭建**：详细阐述设置开发环境的过程，包括IDE的选择与配置、必要...
ffmpeg工具win32平台编译好的静态链接库。对需要打包用于x86的ffmpeg应用，不需要自己编译，直接下载就可用。ffmpeg-20191101-53c21c2-win32-static.zip
11-11
- 分割与合并：可以对音视频文件进行拆分或合并操作。 在Windows平台上，FFmpeg的静态链接库特别适合那些不希望用户安装额外运行库的应用程序，因为所有依赖都已经包含在内，降低了部署的复杂性和潜在的兼容性问题...
TCP/IP多线程上传文件
06-25
本话题主要探讨了如何利用多线程技术实现TCP/IP协议在C++环境下进行文件上传，特别是结合MFC（Microsoft Foundation Classes）和Win32 API。下面我们将深入解析这个主题的相关知识点。 1. **TCP/IP协议**：传输控制...
ffmpeg-win32-v3.2.4.rar
05-06
总的来说，FFmpeg-win32-v3.2.4 提供了一个全面的多媒体处理工具集，适用于个人用户进行文件转换和编辑，同时也适用于开发者构建自己的多媒体应用。虽然这个版本已经是较旧的，但它仍能够处理许多常见的多媒体任务，...
C++ 分割文件
weixin_30323961的博客
02-25 671
实现如下功能： 1.读取参数 -ssource.dat：指定待分割的文件名称； -ddest：指定分割后的文件模板名称，其文件将以dest0001.dat,dest0002.dat.....的方式进行命名 -nsize:指定分割后的文件大小 2.用法 ./split_file-ssource.dat-ddest-n10485760 以10M为单位进行文件分割 3.缺省参数 默认...
用C++写一个文件分割器
AI小男孩的专栏
03-18 3601
c++文件分割器
pi_heif-0.17.0-cp39-cp39-manylinux_2_31_armv7l.whl
最新发布
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
ubuntu20.04-ssh9.8p1-ssl3.0.14-focal-deb-amd64升级加固脚本.zip
07-27
若有新版本请查看文章最后附件地址：https://blog.csdn.net/liuxin638507/article/details/132450367 特点： 1、同时升级openssh与openssl，采用deb包形式，一键快速升级版本，无需每台单独再次进行编译， 2、隐藏openssh-版本号(openssh9.8p1及之后隐藏版本号还未找到方法) 3、已默认安全加固（已有配置跳过） 安装： 执行 bash upgrade_ssl_ssh_ubuntu.sh 进行安装 注意，升级安装后，确保sshd服务正常，请新开终端进行验证测试 验证 openssl版本： openssl version OpenSSL 3.0.14 4 Jun 2024 (Library: OpenSSL 3.0.14 4 Jun 2024) openssh版本： ssh -V OpenSSH_9.8p1, OpenSSL 3.0.14 4 Jun 2024
avif-0.5.0-cp36-cp36m-manylinux1_i686.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
教务管理系统-毕业设计.zip
07-27
教务管理系统-毕业设计.zip
pillow_jxl_plugin-1.2.5-cp39-none-win_amd64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
Win32核心编程教程-C/C++教学
"C/C++教学课程专注于Win32核心编程，涵盖了Windows应用程序的基本类型，如控制台程序、窗口程序和库程序（包括动态库和静态库），并深入讲解了它们之间的区别，如入口函数、文件存在方式和执行方式。此外，教程还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值