注册表操作(Win32, C++)

原创 已于 2024-03-01 22:25:42 修改 · 904 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #windows #Win32

于 2022-12-08 14:19:20 首次发布
本文介绍了一个用于简化Windows注册表操作的C++类库CRegUtils。该类库提供了读写不同类型的注册表值、创建和删除键等常用功能。

以下为简单的封装操作, 常用的注册表操作做了简化操作, 使用例子写在 main.cpp 中, 具体 注册表api 用法可以参考msdn中的详情.

 

CRegUtils.h

#pragma once

#include <wtypesbase.h>
#include <tchar.h>
#include <string>
#include <vector>

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

#define HKCR                (HKEY_CLASSES_ROOT)
#define HKCU                (HKEY_CURRENT_USER)
#define HKLM                (HKEY_LOCAL_MACHINE)
#define HKU                 (HKEY_USERS)

#define HKPD                (HKEY_PERFORMANCE_DATA)
#define HKPT                (HKEY_PERFORMANCE_TEXT)
#define HKPN                (HKEY_PERFORMANCE_NLSTEXT)

#if(WINVER >= 0x0400)
#define HKCC                (HKEY_CURRENT_CONFIG)
#define HKDD                (HKEY_DYN_DATA)
#define HKCULS              (HKEY_CURRENT_USER_LOCAL_SETTINGS)
#endif

class CRegUtils
{
public:

    // 写入 REG_DWORD 类型数据
    static bool SetDword(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, DWORD dwValue);

    // 读取 REG_DWORD 类型数据
    static bool GetDword(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, DWORD& dwValue);

    // 写入 REG_QWORD 类型数据
    static bool SetQword(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, ULONGLONG ullValue);

    // 读取 REG_QWORD 类型数据
    static bool GetQword(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, ULONGLONG& ullValue);

    // 写入 REG_SZ 类型数据
    static bool SetString(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, const _tstring& strValue);

    // 读取 REG_SZ 类型数据
    static bool GetString(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, _tstring& strValue);

    // 写入 REG_BINARY 类型数据
    static bool SetBinary(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, LPCVOID lpData, DWORD dwSize);

    // 读取 REG_BINARY 类型数据
    static bool GetBinary(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, LPVOID lpData, DWORD cbSize);

    // 读取 指定值 所需字节大小
    static bool GetValueSize(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, DWORD& cbSize);

    // 创建 指定键
    static bool CreateKey(HKEY hKey, const _tstring& lpSubKey);

    // 删除 指定键(递归删除)
    static bool DelKey(HKEY hKey, const _tstring& lpSubKey);

    // 删除 指定值
    static bool DelValue(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName);

    // 枚举 指定键 的子键
    static bool EnumKeyName(HKEY hKey, const _tstring& lpSubKey, std::vector<_tstring>& keyList);

    // 枚举 指定键 的值名
    static bool EnumValueName(HKEY hKey, const _tstring& lpSubKey, std::vector<_tstring>& valueList);
};

CRegUtils.cpp

#include "CRegUtils.h"

// 注册表大小限制, 参见 https://learn.microsoft.com/en-us/windows/win32/sysinfo/registry-element-size-limits
#define REG_KEY_NAME_CCH_LIMITS             (255)            // 注册表键名大小限制(项名称包括注册表中项的绝对路径，始终从基项开始)
#define REG_VALUE_NAME_CB_LIMITS            (MAX_PATH)       // 注册表值名大小限制(260 个 ANSI 字符或 16,383 个 Unicode 字符。)
#define REG_VALUE_DATA_CB_LIMITS            (1024 * 1024)    // 注册表值数据大小限制(可用内存（最新格式） 1 MB（标准格式）)

// 写入 REG_DWORD 类型数据
bool CRegUtils::SetDword(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, DWORD dwValue)
{
    LSTATUS ls = ERROR_SUCCESS;

    ls = ::RegSetKeyValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), REG_DWORD, &dwValue, sizeof(dwValue));
    if (ERROR_SUCCESS != ls)
    {
        return false;
    }

    return ERROR_SUCCESS == ls;
}

// 读取 REG_DWORD 类型数据
bool CRegUtils::GetDword(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, DWORD& dwValue)
{
    LSTATUS ls = ERROR_SUCCESS;
    DWORD cbSize = sizeof(dwValue);

    ls = ::RegGetValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), RRF_RT_REG_DWORD/* | RRF_ZEROONFAILURE*/, NULL, &dwValue, &cbSize);
    if (ERROR_SUCCESS != ls)
    {
        return false;
    }

    return ERROR_SUCCESS == ls;
}

// 写入 REG_QWORD 类型数据
bool CRegUtils::SetQword(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, ULONGLONG ullValue)
{
    LSTATUS ls = ERROR_SUCCESS;

    ls = ::RegSetKeyValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), REG_QWORD, &ullValue, sizeof(ullValue));
    if (ERROR_SUCCESS != ls)
    {
        return false;
    }

    return ERROR_SUCCESS == ls;
}

// 读取 REG_QWORD 类型数据
bool CRegUtils::GetQword(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, ULONGLONG& ullValue)
{
    LSTATUS ls = ERROR_SUCCESS;
    DWORD cbSize = sizeof(ullValue);

    ls = ::RegGetValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), RRF_RT_REG_QWORD/* | RRF_ZEROONFAILURE*/, NULL, &ullValue, &cbSize);
    if (ERROR_SUCCESS != ls)
    {
        return false;
    }

    return ERROR_SUCCESS == ls;
}

// 写入 REG_SZ 类型数据
bool CRegUtils::SetString(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, const _tstring& strValue)
{
    LSTATUS ls = ERROR_SUCCESS;

    ls = ::RegSetKeyValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), REG_SZ, strValue.c_str(), (DWORD)((strValue.length() + 1) * sizeof(TCHAR)));
    if (ERROR_SUCCESS != ls)
    {
        return false;
    }

    return ERROR_SUCCESS == ls;
}

// 读取 REG_SZ 类型数据
bool CRegUtils::GetString(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, _tstring& strValue)
{
    LSTATUS ls = ERROR_SUCCESS;
    DWORD dwSize = 0;
    LPVOID lpBuf = NULL;

    //获取数据长度
    ls = ::RegGetValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), RRF_RT_REG_SZ/* | RRF_ZEROONFAILURE*/, NULL, 0, &dwSize);
    if (ERROR_SUCCESS != ls)
    {
        return false;
    }

    // 数据长度超过常规大小限制, 则重新分配空间
    lpBuf = HeapAlloc(GetProcessHeap(), 0, dwSize);
    if (lpBuf)
    {
        ls = ::RegGetValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), RRF_RT_REG_SZ /*| RRF_ZEROONFAILURE*/, NULL, lpBuf, &dwSize);
        if (ERROR_SUCCESS == ls)
        {
            strValue = (LPCTSTR)lpBuf;
        }

        HeapFree(GetProcessHeap(), 0, lpBuf);
    }

    return ERROR_SUCCESS == ls;
}

// 写入 REG_BINARY 类型数据
bool CRegUtils::SetBinary(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, LPCVOID lpData, DWORD cbSize)
{
    LSTATUS ls = ERROR_SUCCESS;
    ls = ::RegSetKeyValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), REG_BINARY, lpData, cbSize);
    return ERROR_SUCCESS == ls;
}

// 读取REG_BINARY类型数据
bool CRegUtils::GetBinary(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, LPVOID lpData, DWORD cbSize)
{
    LSTATUS ls = ERROR_SUCCESS;
    ls = ::RegGetValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), RRF_RT_REG_BINARY/* | RRF_ZEROONFAILURE*/, NULL, lpData, &cbSize);
    return ERROR_SUCCESS == ls;
}

// 读取数据所需字节大小
bool CRegUtils::GetValueSize(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName, DWORD& cbSize)
{
    LSTATUS ls = ERROR_SUCCESS;
    ls = ::RegGetValue(hKey, lpSubKey.c_str(), lpValueName.c_str(), RRF_RT_ANY, NULL, nullptr, &cbSize);
    return (ERROR_SUCCESS == ls) || (ERROR_MORE_DATA == ls);
}

// 创建 指定键
bool CRegUtils::CreateKey(HKEY hKey, const _tstring& lpSubKey)
{
    LSTATUS ls = ERROR_SUCCESS;
    HKEY hNewKey = NULL;
    DWORD dwDisposition = 0;

    ls = ::RegCreateKeyEx(hKey, lpSubKey.c_str(), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hNewKey, &dwDisposition);

    if (hNewKey)
    {
        ::RegCloseKey(hNewKey);
    }

    return ERROR_SUCCESS == ls;
}

// 删除 指定键
bool CRegUtils::DelKey(HKEY hKey, const _tstring& lpSubKey)
{
    LSTATUS ls = ERROR_SUCCESS;
    ls = ::RegDeleteTree(hKey, lpSubKey.c_str());
    return ERROR_SUCCESS == ls;
}

// 删除 指定值
bool CRegUtils::DelValue(HKEY hKey, const _tstring& lpSubKey, const _tstring& lpValueName)
{
    LSTATUS ls = ERROR_SUCCESS;
    ls = ::RegDeleteKeyValue(hKey, lpSubKey.c_str(), lpValueName.c_str());
    return ERROR_SUCCESS == ls;
}

// 枚举 指定键 的子键
bool CRegUtils::EnumKeyName(HKEY hKey, const _tstring& lpSubKey, std::vector<_tstring>& keyList)
{
    TCHAR szKeyName[MAX_PATH] = { 0 };
    DWORD dwCchName = _countof(szKeyName);
    LSTATUS ls = ERROR_SUCCESS;
    HKEY hResultKey = NULL;
    DWORD dwIndex = 0;

    keyList.clear();

    ls = ::RegOpenKeyEx(hKey, lpSubKey.c_str(), 0, KEY_READ, &hResultKey);
    if (ERROR_SUCCESS != ls)
    {
        return false;
    }

    do
    {
        dwCchName = _countof(szKeyName);
        ls = ::RegEnumKeyEx(hResultKey, dwIndex++, szKeyName, &dwCchName, NULL, NULL, NULL, NULL);
        if (ERROR_SUCCESS == ls)
        {
            keyList.push_back(szKeyName);
        }
    } while (ERROR_SUCCESS == ls);

    ::RegCloseKey(hResultKey);

    return true;
}

// 枚举 指定键 的值名
bool CRegUtils::EnumValueName(HKEY hKey, const _tstring& lpSubKey, std::vector<_tstring>& valueList)
{
    TCHAR szValueName[MAX_PATH] = { 0 };
    DWORD dwCchName = _countof(szValueName);
    LSTATUS ls = ERROR_SUCCESS;
    HKEY hResultKey = NULL;
    DWORD dwIndex = 0;

    valueList.clear();

    ls = ::RegOpenKeyEx(hKey, lpSubKey.c_str(), 0, KEY_READ, &hResultKey);
    if (ERROR_SUCCESS != ls)
    {
        return false;
    }

    do
    {
        dwCchName = _countof(szValueName);
        ls = ::RegEnumValue(hResultKey, dwIndex++, szValueName, &dwCchName, NULL, NULL, NULL, NULL);
        if (ERROR_SUCCESS == ls)
        {
            valueList.push_back(szValueName);
        }
    } while (ERROR_SUCCESS == ls);

    ::RegCloseKey(hResultKey);

    return true;
}

main.cpp

// CRegUtils.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include "CRegUtils.h"
#include <iostream>

int main()
{
    BYTE data[MAX_PATH] = { 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39 };
    DWORD dwSize = sizeof(data);
    ULONGLONG qwQword = 0;
    DWORD dwDword = 0;
    _tstring strInfo;

    CRegUtils::SetDword(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("DWORD"), 1234);
    CRegUtils::GetDword(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("DWORD"), dwDword);
    CRegUtils::GetValueSize(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("DWORD"), dwSize);


    CRegUtils::SetQword(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("QWORD"), 5678);
    CRegUtils::GetQword(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("QWORD"), qwQword);
    CRegUtils::GetValueSize(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("QWORD"), dwSize);

    CRegUtils::SetString(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("SZ"), _T("1234567890"));
    CRegUtils::GetString(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("SZ"), strInfo);
    CRegUtils::GetValueSize(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("SZ"), dwSize);

    CRegUtils::SetBinary(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("BINARY"), "1234567890", 10);
    CRegUtils::GetBinary(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("BINARY"), data, sizeof(data));
    CRegUtils::GetValueSize(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("BINARY"), dwSize);

    std::vector<_tstring> keyList;
    std::vector<_tstring> valueList;
    CRegUtils::EnumKeyName(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), keyList);
    CRegUtils::EnumValueName(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), valueList);
    CRegUtils::SetString(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T(""), _T("1234567890-="));
    CRegUtils::GetString(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T(""), strInfo);

    CRegUtils::DelValue(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"), _T("BINARY"));
    CRegUtils::DelKey(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"));

    CRegUtils::CreateKey(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000)"));
    CRegUtils::CreateKey(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000\1)"));
    CRegUtils::CreateKey(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000\2)"));
    CRegUtils::CreateKey(HKLM, _T(R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\0000\3)"));

    return 0;
}

 

 

Win32编程3-注册表读取，创建，修改
qq_16119139的博客
05-31 884
创建窗口原理与上述也一致，页面排版就不多说了，就是CreateWindow函数反复使用，在创建新窗口前会调用QueryRegValue查询键值名称，类型和值，具体解释都在注释里，这里不多叙述，DWORD类型是最简单的，就没写注释，每一种类型都是通过RegGetValue先获取值的大小，然后在读取值并用对应类型接收，最后转为CString类型，并赋值给r，这是全局CString。至此读取，创建，修改注册表的内容就结束了，上述操作经过测试都是可用的，但没有做太多的非法输入处理，主要是懒，而且也用不上。
Windows：注册表结构
qq_55038440的博客
01-25 2694
注册表的各项具体功能，以及实现修改注册表达到自定义系统的目的。
win32读写注册表
07-25
WIn32读写注册表，读写注册表的方式,直接拷贝即可
注册表怎么打开？【图文详解】注册表编辑器？注册表清理？
最新发布
分享技术解决方案，助力小伙伴们高效办公。
11-10 2258
【摘要】本篇以简洁、结构化的方式，逐步教你“如何打开注册表编辑器”。提供快速运行、开始菜单、命令行等多种入口，并用实际操作要点、权限应对与安全提示，帮助你在最短时间内进入注册表编辑界面，同时避免潜在风险。无论你是新手还是有经验的用户，方法清晰、步骤明确，且强调备份与合规性，确保安全高效地完成任务。
注册表操作(VC_Win32)
diaogui7903的博客
11-07 523
目录 注册表概述 注册表相关函数详解 注册表编程 (本章节中例子都是用 VS2005 编译调试的) 注册表概述 概述 注册表是windows操作系统中的一个核心数据库,其中存放着各种参数,直接控制着windows的启动、硬件驱动程序的装载以及一些windows应用程序的运行,从而在整个系统中起着核心作用.这些作用包括了软、硬件的相关配置和状态信息,比如注册表中保存有应...
c++ 操作注册表
andy76123的博客
09-25 401
1. 注册表简介 注册表是为Windows NT和Windows95中所有32位硬件/驱动和32位应用程序设计的数据文件，用于存储系统和应用程序的设置信息。16位驱动在Winnt (Windows New Technology)下无法工作，所以所有设备都通过注册表来控制，一般这些是通过BIOS（基本输入输出系统）来控制的。在Win95下，16位驱动会继续以实模式方式设备工作...
快乐注册表：Win32数据库的快速包装
04-04
《快乐注册表：Win32数据库的快速包装》是一份深入探讨如何利用C++11进行Windows注册表操作的教程。注册表是Windows操作系统中的核心组件，存储着系统配置、软件设置等关键信息。本教程的目标是提供一个简单易用的...
快乐注册表：轻松操作Win32注册表的C++模板
开发一个针对注册表操作的快速包装库需要对Win32 API有深入的理解，同时也需要能够熟练运用C++11的新特性来设计一个高效且用户友好的接口。此外，开发者还需要确保该库能够兼容不同的Windows平台，包括32位和64位...
c++添加开机启动项，win32 api操作注册表，读写注册表
zwcwu31的专栏
11-21 3219
#include #include #include #include #include using namespace std; string getFilePathByWindows(); //判断是否为文件 bool isFile(string path); //修改或者增加注册表 void createStringReg(HKEY hRoot,char *szSubKey,c
win32读取注册表
CHALLENG_EVERYTHING的专栏
08-22 2023
直接代码 bool bIsIE6 = false; HKEY hKey = NULL; DWORD dwType; DWORD dwSize; LONG lReg = RegOpenKey(HKEY_CLASSES_ROOT, "HTTP\\shell\\open\\command", &hKey); if(lReg  != ERROR_SUCCESS) { return fals
win32 注册表操作
weixin_30868855的博客
02-23 156
创建键 RegCreateKeyEx int SetRecordVideoSavedDays(int newSavedDays) 2 { 3 HKEY hSubKey = NULL; 4 LONG lRet = 0; 5 DWORD dwType = 0; 6 int iRet = 0; 7 8...
windows注册表编程
06-15
window 编程心得，算是一种提示 总结。尽量写的详细。不要厌烦
Win32 API 常用函数之三——注册表操作（上）
深红
11-07 6521
【注册表操作】RegOpenKeyExLONG RegOpenKeyEx(  HKEY hKey,  LPCTSTR lpSubKey,  DWORD ulOptions,  REGSAM samDesired,  PHKEY phkResult);打开一个指定的注册表项，值得注意的是注册表的键值是不区分大小写的。第一个参数是主键，可以是预定义的键值，如HKEY_CLASSES
Win32 API 注册表类的编制以及使用 (转)
congmi8078的博客
08-13 179
Win32 API 注册表类的编制以及使用 (转)[@more@]win32 api 注册表类的编制以及使用 一、问题的提出 windows 已由原来的16位 windows 3.x 升级为现今我们使用的32...
注册表编程
超超吵吵的专栏
09-29 584
目录 一、注册表基础 1.1注册表历史背景 1.2注册表作用 1.3注册表结构 1.4各根键主要存储的信息 1.5手动操作注册表 二、注册表编程 2.1相关函数分类 2.2项管理函数 2.2.1项创建函数 2.2.2项打开函数 2.2.3项关闭函数 2.2.4项删除函数 2.3值项管理函数 2.3.1值设置函数 2.3.2值查询函数 2.3.3值项删除函数 2.
C++ 注册表操作
aizongsai2251的博客
07-16 462
一、 LONG RegOpenKeyEx( HKEY hKey, // 需要打开的主键的名称 LPCTSTR lpSubKey, //需要打开的子键的名称 DWORD ulOptions, // 保留，设为0 REGSAM samDesired, // 安全访问标记，也就是权限 PHKEY phkResult // 得到的将要打开键的句柄 ) hKey [输入] 当前打开或者以下预...
Win32注册表操作
zhaotianff的专栏
08-07 1388
使用WinApi操作注册表
【WIN32】WIN32注册表相关
Joeyshaw的博客
07-26 282
如果函数失败，则返回值为 Winerror.h 中定义的非零错误代码。如果函数成功，则返回值为 ERROR_SUCCESS。
C#操作注册表
weixin_30443813的博客
08-12 237
一．注册表巢 在注册表中，最上面的节点是注册表巢（registry hive）。 HKEY_CLASSES_ROOT(HKCR) 包含系统文件类型的细节，以及应用程序可以打开的文件类型，它还包含所有COM组件的注册信息。 HKEY_CURRENT_USER(HKCU) 包含用户目前登陆的机器的用户配置，包括桌面设置、环境变量、网络和打印机连接和其他定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值