【C++11算法设计】模糊匹配算法

原创 已于 2025-11-13 15:23:45 修改 · 置顶 · 627 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #算法 #linux

于 2025-11-13 15:21:53 首次发布

前言

在实际应用中，系统经常需要对一组标识符进行快速匹配。用户可能希望通过通配符模式灵活指定匹配规则，而不是手动列出每一个具体 ID。

其中通配符解释如下：

通配符含义示例可匹配的字符串
?匹配任意单个字符AB?DAB1D, ABXD
*匹配任意长度（0~N）的任意字符12*891289, 123456789, 12ABCD89

场景示例：

  • 用户希望匹配函数 ID：12341、12342、12343…

  • 手动列出所有 ID 很繁琐

  • 希望使用通配符：1234? 或 1234* 或 123?4*9 等自动匹配符合规则的 ID

因此，需要一个 高效、灵活、安全的通配符匹配算法，既支持整数也支持字符串。

算法设计

整体设计思路：

[用户输入模式串]
           │
           ▼
     [去除空白字符]
           │
           ▼
     [指定分隔符(默认逗号)拆分模式串]
           │
           ▼
    [分类存储模式]
   ┌───────────────┐
   │精确匹配集合   │
   │? 模式集合     │
   │* 模式集合     │
   └───────────────┘
           │
           ▼
   [用户输入待匹配值] ──► 整数？ ──► 转字符串
           │
           ▼
       [匹配顺序]
   ┌─────┬───────┬─────┐
   │精确匹配│? 模式 │* 模式│
   └─────┴───────┴─────┘
           │
           ▼
   匹配成功？ → true
   否 → 返回 false

说明：

  1. 模式预处理（SetFuncIDs / ParseFuncIDs）

    • 将输入的模式字符串拆分成若干条规则（支持指定，默认逗号分隔）

    • 去除空格、制表符等空白字符（NormalizeAndRemoveSpaces）

    • 将模式按类型分类存储：

      • 精确匹配集合（m_usExactMatchSet）：没有通配符的字符串

      • ? 模式集合（m_mapQuestionPatterns）：按长度分组存储，便于快速筛选

      • * 模式集合（m_vsWildcardPatterns）：存储带 * 的复杂模式

  2. 匹配流程（IsMatch / IsMatchInternal）

    • 输入可以是多种类型：int32_t/uint32_t/int64_t/uint64_t/std::string/const char*

    • 对整型输入：

      • 通过 snprintf 将数字转为字符串

      • 检查返回值是否异常或超出缓冲区

    • 对字符串输入：

      • 直接使用原字符串或 c_str()

    • 匹配顺序：

      • 精确匹配集合：直接哈希查找（O(1)）

      • ? 模式集合：按长度筛选，然后逐字符匹配

      • * 模式集合：双指针回溯匹配（WildcardMatch）

C++代码示例

#include <string>
#include <vector>
#include <unordered_set>
#include <map>
#include <cstdint>
#include <iostream>
#include <new>
#include <cstring>
#include <cctype>    // for isspace
#include <algorithm> // for remove_if
#include <cinttypes> // 提供 PRId32 / PRIu32

const uint8_t APPEND_FUNCIDS_MODE = 1 << 2; // 追加模式标志位

/**
 * @brief FuncMatcher 类用于匹配函数 ID 是否符合预定义的通配规则。
 *
 * 通配符支持规则：
 *   - '?' 匹配任意单个字符
 *   - '*' 匹配任意多个字符（包括空字符）
 */
class FuncMatcher
{
public:
    /**
     * @brief 构造函数，解析并缓存通配符规则。
     */
    explicit FuncMatcher() noexcept
    {
        ClearAll();
        m_nExceptionCount = 0;
    }

    /**
     * @brief 通用匹配接口，支持 int64_t
     * @param i64FuncID 待匹配的数值
     * @return true 如果匹配成功，否则 false
     */
    bool IsMatch(const int64_t i64FuncID) const
    {
        char buf[21]; // 符号 + 19位 + '\0'
        int len = snprintf(buf, sizeof(buf), "%" PRId64, i64FuncID);
        if (len < 0 || len >= static_cast<int>(sizeof(buf)))
        {
            return false;
        }
        return IsMatchInternal(buf, len);
    }

    /**
     * @brief 通用匹配接口，支持 uint64_t
     * @param u64FuncID 待匹配的数值
     * @return true 如果匹配成功，否则 false
     */
    bool IsMatch(const uint64_t u64FuncID) const
    {
        char buf[20]; // 最大 19位 + '\0'
        int len = snprintf(buf, sizeof(buf), "%" PRIu64, u64FuncID);
        if (len < 0 || len >= static_cast<int>(sizeof(buf)))
        {
            return false;
        }
        return IsMatchInternal(buf, len);
    }

    /**
     * @brief 通用匹配接口，支持 int32_t
     * @param i32FuncID 待匹配的数值
     * @return true 如果匹配成功，否则 false
     */
    bool IsMatch(const int32_t i32FuncID) const
    {
        char buf[12]; // 符号 + 10位 + '\0'
        int len = snprintf(buf, sizeof(buf), "%" PRId32, i32FuncID);
        if (len < 0 || len >= static_cast<int>(sizeof(buf)))
        {
            return false;
        }
        return IsMatchInternal(buf, len);
    }

    /**
     * @brief 通用匹配接口，支持 uint32_t
     * @param u32FuncID 待匹配的整数 ID
     * @return true 如果匹配成功，否则 false
     */
    bool IsMatch(const uint32_t u32FuncID) const
    {
        char buf[11]; // 10位 + '\0'
        int len = snprintf(buf, sizeof(buf), "%" PRIu32, u32FuncID);
        if (len < 0 || len >= static_cast<int>(sizeof(buf)))
        {
            return false;
        }
        return IsMatchInternal(buf, len);
    }

    /**
     * @brief 通用匹配接口，支持 std::string
     * @param strFuncID 待匹配的字符串
     * @return true 如果匹配成功，否则 false
     */
    bool IsMatch(const std::string &strFuncID) const
    {
        return IsMatchInternal(strFuncID.c_str(), strFuncID.size());
    }

    /**
     * @brief 通用匹配接口，支持 const char*
     * @param lpszFuncID 待匹配的 C 风格字符串
     * @return true 如果匹配成功，否则 false
     */
    bool IsMatch(const char *lpszFuncID) const
    {
        if (!lpszFuncID)
        {
            return false;
        }
        size_t len = strlen(lpszFuncID);
        return IsMatchInternal(lpszFuncID, len);
    }

    /**
     * @brief 获取异常发生次数统计
     */
    inline uint32_t GetExceptionCount() const noexcept
    {
        return m_nExceptionCount;
    }

    /**
     * @brief 设置函数匹配模式。
     *
     * 默认行为是 **覆盖原有模式**，除非通过 nFlag 指定追加模式。
     *
     * @param szlpFuncIDs 新的模式字符串，以逗号分隔
     * @param sep 分隔符， 默认逗号
     * @param nFlag 控制模式设置方式：
     *              - 0：覆盖原有模式（默认）
     *              - APPEND_FUNCIDS_MODE：追加到现有模式
     * @return true 如果匹配成功，否则 false
     */
    bool SetFuncIDs(const char *szlpFuncIDs, char seq = ',', uint32_t nFlag = 0)
    {
        if (nFlag == 0) // 覆盖模式，清空原有缓存
        {
            ClearAll();
        }

        try
        {
            return ParseFuncIDs(szlpFuncIDs, seq);
        }
        catch (...)
        {
            ClearAll(); // 异常则统统清空数据
            ++m_nExceptionCount;
            return false;
        }
    }

private: // 内部函数
    /**
     * @brief 清空所有内部缓存数据。
     */
    void ClearAll() noexcept
    {
        m_usExactMatchSet.clear();
        m_mapQuestionPatterns.clear();
        m_vsWildcardPatterns.clear();
    }

    /**
     * @brief 内部实现函数，执行实际匹配逻辑
     * @param lpszFuncID 待匹配字符串
     * @param nLen     字符串长度
     * @return true 如果匹配成功，否则 false
     */
    bool IsMatchInternal(const char *lpszFuncID, size_t nLen) const
    {
        try
        {
            // 1. 精确匹配集合
            if (m_usExactMatchSet.count(lpszFuncID))
            {
                return true;
            }

            // 2. 含 '?' 的匹配集合
            // 提前长度过滤
            auto it = m_mapQuestionPatterns.find(nLen);
            if (it != m_mapQuestionPatterns.end())
            {
                for (const auto &pattern : it->second)
                {
                    if (MatchQuestionOnly(pattern.c_str(), lpszFuncID, nLen))
                    {
                        return true;
                    }
                }
            }

            // 3. 含 '*' 的匹配集合
            for (const auto &pattern : m_vsWildcardPatterns)
            {
                if (WildcardMatch(pattern.c_str(), lpszFuncID))
                {
                    return true;
                }
            }

            return false;
        }
        catch (...)
        {
            // 记录异常计数，但保持原有行为（返回 false）
            ++m_nExceptionCount;
            return false;
        }
    }

    /**
     * @brief 移除字符串中所有空白字符（包括空格、制表符、换行等）
     */
    static void NormalizeAndRemoveSpaces(std::string &s) noexcept
    {
        s.erase(std::remove_if(s.begin(), s.end(),
                               [](char c)
                               {
                                   return std::isspace(static_cast<unsigned char>(c));
                               }),
                s.end());
    }

    /**
     * @brief 解析输入字符串并分类存储模式。
     * @param szlpFuncIDs 输入模式字符串，以逗号分隔
     * @param sep 分隔符
     * @return true 如果匹配成功，否则 false
     */
    bool ParseFuncIDs(const char *szlpFuncIDs, char seq)
    {
        if (!szlpFuncIDs)
        {
            return false;
        }

        std::string strFuncIDs(szlpFuncIDs);

        // 将整个输入字符串去除所有空白
        NormalizeAndRemoveSpaces(strFuncIDs);

        size_t start = 0;
        while (start < strFuncIDs.size())
        {
            size_t pos = strFuncIDs.find(seq, start);
            std::string item = (pos == std::string::npos) ? strFuncIDs.substr(start) : strFuncIDs.substr(start, pos - start);
            start = (pos == std::string::npos) ? strFuncIDs.size() : pos + 1;

            // 输入中连续逗号或空白导致的空项则跳过
            if (item.empty())
            {
                continue;
            }

            if (item.find('*') != std::string::npos)
            {
                m_vsWildcardPatterns.emplace_back(std::move(item));
            }
            else if (item.find('?') != std::string::npos)
            {
                m_mapQuestionPatterns[item.size()].emplace_back(std::move(item));
            }
            else
            {
                m_usExactMatchSet.insert(std::move(item));
            }
        }

        return true;
    }

    /**
     * @brief 匹配仅含 '?' 的模式。
     * @param szPattern 模式字符串
     * @param szStr     待匹配字符串
     * @param nLen      长度（已知相等）
     * @return true 若匹配成功
     */
    static bool MatchQuestionOnly(const char *pattern, const char *lpszStr, size_t len) noexcept
    {
        for (size_t i = 0; i < len; ++i)
        {
            if (pattern[i] != '?' && pattern[i] != lpszStr[i])
            {
                return false;
            }
        }
        return true;
    }

    /**
     * @brief 通配符匹配（支持 '*' 与 '?'），双指针回溯匹配算法
     * @param szPattern 模式字符串
     * @param szStr     待匹配字符串
     * @return true 若匹配成功
     */
    static bool WildcardMatch(const char *lpszPattern, const char *lpszStr) noexcept
    {
        const char *pStar = nullptr;
        const char *sStar = nullptr;

        while (*lpszStr)
        {
            if (*lpszPattern == '?' || *lpszPattern == *lpszStr)
            {
                ++lpszPattern;
                ++lpszStr;
            }
            else if (*lpszPattern == '*')
            {
                while (*lpszPattern == '*') // 多个*则忽略
                {
                    ++lpszPattern;
                }

                if (*lpszPattern == '\0') // *可以不占一位
                {
                    return true;
                }

                pStar = lpszPattern;
                sStar = lpszStr;
            }
            else if (pStar)
            {
                lpszPattern = pStar;
                lpszStr = ++sStar;
            }
            else
            {
                return false;
            }
        }

        while (*lpszPattern == '*')
        {
            ++lpszPattern;
        }

        return *lpszPattern == '\0';
    }

private:
    std::unordered_set<std::string> m_usExactMatchSet;                // 无通配符的精确匹配表
    std::map<size_t, std::vector<std::string>> m_mapQuestionPatterns; // 按长度分组的 '?' 模式
    std::vector<std::string> m_vsWildcardPatterns;                    // 含 '*' 的模式
    mutable uint32_t m_nExceptionCount;                               // 异常统计次数
};

int main()
{
    // 目标串
    const char *szlpFuncIDs = " 123?1 , 123456? ,123456* ,123843*3, 3819 , 3819?, 408?38*38 ";

    FuncMatcher *lpMatcher = new (std::nothrow) FuncMatcher();
    if (lpMatcher == nullptr)
    {
        std::cerr << "FuncMatcher init failed.\n";
        delete lpMatcher;
        return -1;
    }

    lpMatcher->SetFuncIDs(szlpFuncIDs);

    std::cout << std::boolalpha;

    // 测试数据，包含空格、制表符、换行等
    std::vector<std::pair<std::string, std::string>> vecTestData = {
        {"uint64_t", "408738464738"},
        {"uint64_t", "408738747373839"},
        {"uint32_t", "12341"},
        {"uint32_t", "1234567"},
        {"uint32_t", "55555"},
        {"uint32_t", "1238439934"},
        {"uint32_t", "3811"},
        {"uint32_t", "38192"},
        {"std::string", "123843993"},
        {"std::string", "99999"},
        {"const char*", "1234568"},
        {"const char*", "11111"},
        {"std::string", " 12341 "},     // 包含空格
        {"std::string", "\t1234567\n"}, // 包含制表符与换行
        {"std::string", " 38192 "}      // 包含空格
    };

    for (size_t i = 0; i < vecTestData.size(); ++i)
    {
        const auto &sType = vecTestData[i].first;
        const auto &sValue = vecTestData[i].second;
        bool bMatch = false;

        if (sType == "uint32_t")
        {
            uint32_t value = static_cast<uint32_t>(std::stoul(sValue));
            bMatch = lpMatcher->IsMatch(value);
        }
        else if (sType == "int32_t")
        {
            int32_t value = static_cast<int32_t>(std::stoi(sValue));
            bMatch = lpMatcher->IsMatch(value);
        }
        else if (sType == "uint64_t")
        {
            uint64_t value = static_cast<uint64_t>(std::stoull(sValue));
            bMatch = lpMatcher->IsMatch(value);
        }
        else if (sType == "int64_t")
        {
            int64_t value = static_cast<int64_t>(std::stoll(sValue));
            bMatch = lpMatcher->IsMatch(value);
        }
        else if (sType == "std::string")
        {
            bMatch = lpMatcher->IsMatch(sValue);
        }
        else if (sType == "const char*")
        {
            bMatch = lpMatcher->IsMatch(sValue.c_str());
        }

        std::cout << sType << " \"" << sValue << "\" -> " << bMatch << "\n";
    }

    // 输出异常统计（可选）
    std::cout << "Exception count: " << lpMatcher->GetExceptionCount() << std::endl;

    delete lpMatcher;
    return 0;
}

输出：

实现功能点

功能类别功能点说明
输入类型支持多类型匹配接口支持 int32_t、uint32_t、int64_t、uint64_t、std::string、const char* 等类型输入
整型自动转换整型输入通过 snprintf 转换为字符串再参与匹配，保证统一逻辑
字符串直接匹配直接使用 std::string 或 C 风格字符串输入进行匹配
通配符匹配规则? 通配符匹配任意单个字符（长度必须一致）
* 通配符匹配任意长度字符（可为零长度）
混合通配符支持 * 与 ? 混合使用，如 "408?38*38"
模式管理机制模式分类存储

精确匹配集合（无通配符）

? 模式集合（按长度分组）

* 模式集合（支持多层通配）

模式设置接口SetFuncIDs()：从字符串中解析多条规则（默认以逗号分隔）
模式追加功能可通过标志位 APPEND_FUNCIDS_MODE 选择追加模式或覆盖模式
可自定义分隔符用户可自定义除逗号外的其他单个字符的分隔符

总结

本文支持根据用户定义的通配规则，判断输入的数值或字符串是否与模式串精确匹配或通配匹配。

C++ 字符串匹配(KMP算法)
GPU全栈博主
06-10 442
（1）：一是在子串上下文章，检查字串中是否有前后相同的字符，并记录在一个数组中。如果有前后相同的字符，则加以标记，在比较时可以跳过，因为前面已比较过了，后面不用重复比较一遍。字符串匹配算法要求输入主串（string）和子串（pattarn），然后返回子串在主串中第一次出现的位置。（2）：二是在主串上下文章，采用主串不回退的原则，主串一直向前遍历，这样就会显著减少匹配次数。
C/C++ 中文模糊查询算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-08 2905
中文模糊查询算法是一种根据用户给定的关键词，在中文文本中进行模糊匹配的算法。其主要目的是在给定的文本中找到与关键词相似的文本片段。
C++视觉算法实战指南
keny-大成的博客
07-23 1014
本文介绍了C++在计算机视觉领域的常用算法实现，涵盖OpenCV图像处理、PCL点云处理和OpenCV DNN模块三大方向。主要内容包括：1. OpenCV基础：图像滤波、边缘检测、特征匹配等传统算法实现；2. PCL点云处理：滤波、分割、配准、特征提取等点云操作方法；3. OpenCV DNN模块：YOLO、ResNet等深度学习模型的部署应用。文章提供了大量可直接运行的代码示例，适合开发者快速实现各类视觉任务，同时强调了算法选择和性能优化的注意事项。
C++的算法：AC自动机
全栈工程师Linda的博客
06-04 1425
C++的算法：AC自动机
算法——模糊算法
热门推荐
百锦再的博客
12-12 1万+
模糊算法，也称为模糊逻辑或模糊推理，是一种基于模糊集合理论的数学方法，用于处理模糊或不确定性信息。与传统的二值逻辑相比，模糊逻辑允许数据具有模糊性、不确定性和部分真实性。
C++通配符模糊匹配
lee_wayway的博客
09-12 2226
'?'可匹配任意单个字符. '*'可匹配任意字符，包括空. 例如: s: abc p: a?c ->匹配成功 s: abc p: a* ->匹配成功 实现基本逻辑是从左至右依次匹配，匹配到'*'时，更新cache，将*依次扩展字符进行匹配。 #include<iostream> #include <fstream> #include<string> static bool isMatch(c...
C++搜索内存特征码 支持模糊匹配
wtujoxk的博客
04-06 1031
【代码】C++搜索内存特征码 支持模糊匹配。
c++ 模糊搜索 正则表达式_模糊搜索算法（近似字符串匹配算法）
weixin_39959615的博客
01-17 1785
考虑到您正在尝试对学校名称列表进行模糊搜索，因此我认为您不希望使用Levenshtein距离之类的传统字符串相似性。 我的假设是，您正在接受用户的输入(键盘输入或通过电话说出)，并且想要快速找到匹配的学校。距离量度告诉您两个字符串基于替换，删除和插入的相似程度。 但是这些算法并没有真正告诉您有关字符串与人类语言中单词的相似程度的任何信息。例如，考虑单词“ smith”，“ smythe”和“ sm...
KMP算法(c++)
客舟中
12-28 1312
算法描述 使用文本编辑的时候，常常会用到搜索功能，比如在一个文本"abcabcabcabcabcd"里查找"abcabcd"第一次出现的位置，这个功能如何用代码来解决呢？ 最直观的办法就是暴力比较，从文本第一个字符开始逐个和要匹配的字符一一比较，遇到不相等的字符，则倒退从第二个字符重复上面的步骤： 一共比较了六次。通过观察可以发现，有些比较是可以省掉的： 真正的有效比较一共只需要四次。 如何能高效的搜索，最好是遍历文本的次数只有一次。也就是假如有两个指针分别指向文本和匹配字符串，文本的..
C++ 字符串模糊匹配
pisuto的博客
12-23 3824
C++ 字符串模糊匹配 参考链接：https://github.com/tajmone/fuzzy-search，https://www.forrestthewoods.com/blog/reverse_engineering_sublime_texts_fuzzy_match/ 对原有的C语言代码进行了C++简单改写，使用std::string替换了char字符 详细解读，待续 #pragma once #include <string> #include <vector
C/C++实现字符串模糊匹配
09-02
在C/C++编程中，字符串模糊匹配是一种常见的需求，特别是在处理配置文件、权限控制或文本搜索等场景。本文主要探讨了如何在Linux和Windows平台上利用fnmatch函数来实现这一功能。 `fnmatch`函数是POSIX标准定义的一...
KMP中文字符匹配算法的C++实现
01-29
KMP算法的核心是构建一个部分匹配表（也称为失败函数），用于在主串中遇到不匹配字符时，避免回溯，从而提高搜索效率。对于中文字符匹配，我们需要注意编码问题，因为中文字符通常采用UTF-8或GBK等多字节编码。 在...
基于Horspool算法的模糊匹配.pdf
03-15
一种方法是将模式串转化为特定的二进制数序列，这使得算法在保持精确匹配能力的同时，也能处理模糊匹配的情况。通过这种方式，Horspool算法可以适应不同类型的模糊信息，比如处理通配符或者特定字符集的模糊需求。 ...
【C++】List容器模拟实现（超详细）
qq_62473190的博客
11-12 753
本文详细介绍了如何从零开始模拟实现STL中的list容器。主要内容包括： 设计list节点类； 实现迭代器类，通过运算符重载模拟指针行为； 构建list类框架，实现基本操作如插入、删除等； 解决const迭代器问题，使用模板参数优化实现； 处理迭代器失效问题，完善拷贝构造和赋值运算符； 实现多种构造函数。 文中重点讲解了list作为双向循环链表的核心实现思想，特别是迭代器对节点指针的封装技巧。通过大量代码示例展示了list各功能的实现细节。最终完成的list容器支持标准STL list的基本操作和接口。
C语言中共享内存完整示例及函数详解
最新发布
m0_73932536的博客
11-16 203
C语言中共享内存完整示例及函数详解
16、C++：AVL树
C_Liu_的博客
11-16 724
AVL树是一种高度平衡的二叉搜索树，其左右子树高度差的绝对值不超过1。本文详细介绍了AVL树的实现原理：1. 节点结构包含平衡因子(bf)记录左右子树高度差；2. 插入操作分为三步：按BST规则插入、更新平衡因子、必要时通过旋转调整结构；3. 重点讲解了四种旋转操作（左单旋、右单旋、左右双旋、右左双旋）及其实现代码；4. 分析了不同情况下平衡因子的更新规则和旋转条件。AVL树通过严格的平衡控制，将查找效率保持在O(logN)，适用于需要高效查找的场景。
前缀和与差分（一维和二维）
m0_61662123的博客
11-14 446
介绍前缀和和差分的使用，给出一维和二维前缀和与差分的模板
C语言变量与内存深度解析
Shylock_Mister的博客
11-13 794
本文详细介绍了C语言中的变量类型、内存布局和作用域规则。主要内容包括： 进程内存空间分布：划分为栈、堆、BSS段、数据段和代码段，分别存储局部变量、动态内存、未初始化全局变量等。 变量类型与存储： 局部变量存储在栈上，函数结束时销毁 静态变量存储在数据段/BSS段，生命周期为整个程序 全局变量也存储在数据段/BSS段 常量存储在代码段或数据段 作用域规则： 块作用域（花括号内） 文件作用域（全局变量） 函数作用域（goto标签） 常见陷阱：包括返回局部变量地址、未初始化变量等问题及解决方案。
C语言反编译技术解析 | C语言反编译的挑战与应用
ekdjyw_767的博客
11-13 286
然而，反编译技术本身面临着许多挑战，其中最主要的是反编译结果的准确性和可读性。未来，随着人工智能、大数据和区块链等技术的快速发展，我们可以期待更多新兴语言的涌现，同时也需要持续学习和掌握多种编程语言，才能在激烈的竞争中脱颖而出。总结来说，C语言反编译技术作为一种强大的工具，具有广泛的应用前景，但同时也伴随着技术和法律方面的挑战。首先，Python继续稳居榜首。Java和C#等传统语言仍然有着广泛的应用，尤其是在企业级开发和后端系统建设方面，Java凭借其稳定性和跨平台的特点，一直是开发大型系统的首选。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SarPro

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值