命名管道(Win32, C++)

已于 2024-03-01 22:10:05 修改
阅读量397 收藏
点赞数
分类专栏： Win32 文章标签： win32 c++ windows 管道 1024程序员节
于 2023-10-23 13:01:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flame_Cyclone/article/details/133987446
版权

命名管道简单封装

 

CNamedPipe.h

#pragma once
#include <string>
#include <windows.h>
#include <tchar.h>

#pragma warning(disable:4200)

class CNamedPipe
{
public:
    CNamedPipe();

    ~CNamedPipe();

    CNamedPipe(const CNamedPipe& r) = delete;
    CNamedPipe& operator = (const CNamedPipe& r) = delete;

    //
    // @brief: 创建命名管道
    // @param: lpName           管道名
    // @ret: bool               true: 创建成功 false: 创建失败
    bool Create(LPCTSTR lpName);

    //
    // @brief: 等待客户端连接命名管道
    // @param: nTimeOut         超时等待(毫秒)
    // @ret: bool               true: 连接成功 false: 连接失败
    bool WaitConnect(DWORD nTimeOut = INFINITE);

    //
    // @brief: 关闭由Create 创建的管道
    // @param: void
    // @ret: bool               true: 关闭 成功 false: 关闭 失败
    bool Disconnect();

    //
    // @brief: 打开已存在的命名管道
    // @param: lpName           管道名
    // @ret: bool               true: 打开成功 false: 打开失败
    bool Open(LPCTSTR lpName, DWORD nTimeOut = INFINITE);

    //
    // @brief: 管道是否有效
    // @param: void
    // @ret: bool               true: 可用 false: 无效
    bool IsValid();

    //
    // @brief: 关闭管道
    // @param: void
    // @ret: void
    void Close(void);

    //
    // @brief: 从读取管道数据
    // @param: lpData           数据存放缓冲
    // @param: nSize            缓冲大小(字节)
    // @param: lpBytesRead      指向实际读取大小(字节)的指针
    // @param: nTimeOut         读取超时(毫秒)
    // @ret: bool               true: 读取成功 false: 读取失败
    bool Read(LPVOID lpData, DWORD nSize, LPDWORD lpBytesRead = nullptr, DWORD nTimeOut = INFINITE);

    //
    // @brief: 向管道写入数据
    // @param: lpData           写入数据指针
    // @param: nSize            写入数据大小(字节)
    // @param: lpBytesWritten   指向实际写入大小(字节)的指针
    // @param: nTimeOut         写入超时(毫秒)
    // @ret: bool               true: 写入成功 false: 写入失败
    bool Write(LPCVOID lpData, DWORD nSize, LPDWORD lpBytesWritten = nullptr, DWORD nTimeOut = INFINITE);

private:

    //
    // @brief: 初始化对象占用
    // @param: void
    // @ret: void
    bool Initialize();

    //
    // @brief: 释放对象占用
    // @param: void
    // @ret: void
    void Uninitialize();

private:
    HANDLE m_hNamedPipe = INVALID_HANDLE_VALUE;
    HANDLE m_hReadEvent = NULL;
    HANDLE m_hWriteEvent = NULL;
    LPVOID m_pBuffer = nullptr;
    bool m_bInit = false;
    bool m_bConnected = false;
};

CNamedPipe.cpp

#include "CNamedPipe.h"
#include <StrSafe.h>
#include <tchar.h>

#define PIPE_NAME_PREFIX             TEXT(R"(\\.\pipe\)")    //管道前缀名
#define PIPE_MAX_TIMEOUT             (3000)                  //管道打开超时
#define PIPE_BUF_MAX_SIZE            (1024 * 1024)           //管道发送缓冲大小(字节)
#define PIPE_MAX_CONNECT             (16)                    //IPC最大连接数

typedef struct _PIPE_DATA
{
    DWORD dwSize = 0;
    BYTE data[0];
}PIPE_DATA, * PPIPE_DATA;

CNamedPipe::CNamedPipe() :
    m_pBuffer(nullptr),
    m_hNamedPipe(INVALID_HANDLE_VALUE),
    m_hReadEvent(NULL),
    m_hWriteEvent(NULL),
    m_bConnected(false),
    m_bInit(false)
{
    //初始化读写缓冲与事件句柄
    Initialize();
}

CNamedPipe::~CNamedPipe()
{
    //释放读写缓冲与事件句柄
    Uninitialize();
}

bool CNamedPipe::Create(LPCTSTR lpName)
{
    TCHAR szPipeName[MAX_PATH];
    SECURITY_ATTRIBUTES sa = { 0 };
    SECURITY_DESCRIPTOR sd = { 0 };
    bool isSuccess = false;

    sa.nLength = sizeof(sa);
    sa.bInheritHandle = FALSE;
    sa.lpSecurityDescriptor = &sd;

    if (INVALID_HANDLE_VALUE != m_hNamedPipe)
    {
        return true;
    }

    //设置权限, 防止低权限进程不能打开高权限进程创建的管道
    (void)::InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
    (void)::SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
    (void)::StringCchPrintf(szPipeName, _countof(szPipeName), TEXT("%s%s"), PIPE_NAME_PREFIX, lpName);

    do
    {
        m_hNamedPipe = ::CreateNamedPipe(
            szPipeName,
            PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
            PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
            PIPE_MAX_CONNECT,
            PIPE_BUF_MAX_SIZE,
            PIPE_BUF_MAX_SIZE,
            PIPE_MAX_TIMEOUT,
            &sa
        );

        if (INVALID_HANDLE_VALUE == m_hNamedPipe)
        {
            break;
        }

        isSuccess = true;

    } while (false);

    if (!isSuccess)
    {
        this->Close();
    }

    return isSuccess;
}

bool CNamedPipe::Open(LPCTSTR lpName, DWORD nTimeOut/* = INFINITE*/)
{
    TCHAR szPipeName[MAX_PATH] = { 0 };
    bool isSuccess = false;

    (void)::StringCchPrintf(szPipeName, _countof(szPipeName), TEXT("%s%s"), PIPE_NAME_PREFIX, lpName);

    if (INVALID_HANDLE_VALUE != m_hNamedPipe)
    {
        return true;
    }

    ULONGLONG ullCurTick = ::GetTickCount64();

    do
    {
        m_hNamedPipe = ::CreateFile(
            szPipeName,
            GENERIC_READ | GENERIC_WRITE,
            0,
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
            NULL
        );

        //管道句柄有效则终止循环
        if (INVALID_HANDLE_VALUE != m_hNamedPipe)
        {
            isSuccess = true;
            break;
        }

        //若错误原因不是因为所有管道范例都在使用中, 则退出循环
        if (ERROR_PIPE_BUSY != ::GetLastError())
        {
            break;
        }

        //等待命名管道的实例可用于连接
        if (::WaitNamedPipe(szPipeName, 1000))
        {
            continue;
        }

        //无限等待则不需要检查超时
        if (INFINITE == nTimeOut)
        {
            continue;
        }

        //执行操作超时则退出循环
        if (::GetTickCount64() - ullCurTick > nTimeOut)
        {
            break;
        }

    } while (INVALID_HANDLE_VALUE == m_hNamedPipe);

    if (!isSuccess)
    {
        this->Close();
    }

    return isSuccess;
}

bool CNamedPipe::WaitConnect(DWORD nTimeOut)
{
    OVERLAPPED Overlapped = { 0 };
    bool isConnected = false;

    if (INVALID_HANDLE_VALUE == m_hNamedPipe)
    {
        return false;
    }

    Overlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    if (NULL == Overlapped.hEvent)
    {
        return false;
    }

    isConnected = ::ConnectNamedPipe(m_hNamedPipe, &Overlapped);

    if (!isConnected)
    {
        DWORD dwError = ::GetLastError();

        //管道关闭中
        if (ERROR_NO_DATA == dwError)
        {
            isConnected = false;
        }

        //操作处于挂起状态
        if (ERROR_IO_PENDING == dwError)
        {
            if (WAIT_OBJECT_0 == ::WaitForSingleObject(Overlapped.hEvent, nTimeOut))
            {
                isConnected = true;
            }
        }

        //管道已经连接
        if (ERROR_PIPE_CONNECTED == dwError)
        {
            isConnected = true;
        }
    }

    if (NULL != Overlapped.hEvent)
    {
        ::CloseHandle(Overlapped.hEvent);
    }

    m_bConnected = isConnected;

    return isConnected;
}

bool CNamedPipe::Disconnect()
{
    if (INVALID_HANDLE_VALUE == m_hNamedPipe)
    {
        return false;
    }

    //参数句柄必须由 CreateNamedPipe 函数创建
    return ::DisconnectNamedPipe(m_hNamedPipe);
}

void CNamedPipe::Close()
{
    if (INVALID_HANDLE_VALUE != m_hNamedPipe)
    {
        if (m_bConnected)
        {
            ::FlushFileBuffers(m_hNamedPipe);
            ::DisconnectNamedPipe(m_hNamedPipe);
            m_bConnected = false;
        }
        ::CloseHandle(m_hNamedPipe);
        m_hNamedPipe = INVALID_HANDLE_VALUE;
    }
}

bool CNamedPipe::IsValid()
{
    return INVALID_HANDLE_VALUE != m_hNamedPipe;
}

bool CNamedPipe::Read(LPVOID lpData, DWORD nSize, LPDWORD lpBytesRead/* = nullptr*/, DWORD nTimeOut)
{
    OVERLAPPED Overlapped = { 0 };
    Overlapped.hEvent = m_hReadEvent;
    DWORD dwBytesTransferred = 0;
    bool isSuccess = false;

    if (nullptr == m_pBuffer ||
        nullptr == lpData ||
        0 == nSize ||
        nSize > PIPE_BUF_MAX_SIZE
        )
    {
        return false;
    }

    PPIPE_DATA pData = (PPIPE_DATA)m_pBuffer;
    if (!::ReadFile(m_hNamedPipe, &pData->dwSize, sizeof(PIPE_DATA), NULL, &Overlapped))
    {
        //管道已结束
        if (ERROR_BROKEN_PIPE == ::GetLastError())
        {
            return false;
        }

        if (ERROR_IO_PENDING != ::GetLastError())
        {
            return false;
        }

        if (WAIT_OBJECT_0 != ::WaitForSingleObject(Overlapped.hEvent, nTimeOut))
        {
            return false;
        }
    }

    if (pData->dwSize > PIPE_BUF_MAX_SIZE)
    {
        return false;
    }

    if (!::ReadFile(m_hNamedPipe, pData->data, pData->dwSize, NULL, &Overlapped))
    {
        if (ERROR_IO_PENDING != ::GetLastError())
        {
            return false;
        }

        if (WAIT_OBJECT_0 != ::WaitForSingleObject(Overlapped.hEvent, nTimeOut))
        {
            return false;
        }
    }

    if (::GetOverlappedResult(m_hNamedPipe, &Overlapped, &dwBytesTransferred, true))
    {
        isSuccess = true;
        if (lpBytesRead)
        {
            *lpBytesRead = dwBytesTransferred;
        }
    }

    if (isSuccess)
    {
        if (nSize < pData->dwSize)
        {
            ::memcpy_s(lpData, nSize, pData->data, nSize);
        }
        else
        {
            ::memcpy_s(lpData, nSize, pData->data, pData->dwSize);
        }
    }

    return isSuccess;
}

bool CNamedPipe::Write(LPCVOID lpData, DWORD nSize, LPDWORD lpBytesWritten/* = nullptr*/, DWORD nTimeOut)
{
    OVERLAPPED Overlapped = { 0 };
    Overlapped.hEvent = m_hWriteEvent;
    DWORD dwBytesTransferred = 0;
    bool isSuccess = false;

    if (nullptr == m_pBuffer ||
        nullptr == lpData ||
        0 == nSize ||
        nSize > PIPE_BUF_MAX_SIZE
        )
    {
        return false;
    }

    PPIPE_DATA pData = (PPIPE_DATA)m_pBuffer;
    DWORD dwBytesToWrite = nSize + sizeof(PIPE_DATA);
    pData->dwSize = nSize;
    ::memcpy_s(pData->data, PIPE_BUF_MAX_SIZE, lpData, nSize);

    if (::WriteFile(m_hNamedPipe, pData, dwBytesToWrite, NULL, &Overlapped))
    {
        return true;
    }

    //管道正在被关闭
    if (ERROR_NO_DATA == ::GetLastError())
    {
        return false;
    }

    //管道已结束
    if (ERROR_BROKEN_PIPE == ::GetLastError())
    {
        return false;
    }

    //重叠
    if (ERROR_IO_PENDING != ::GetLastError())
    {
        return false;
    }

    if (WAIT_OBJECT_0 != ::WaitForSingleObject(Overlapped.hEvent, nTimeOut))
    {
        return false;
    }

    if (::GetOverlappedResult(m_hNamedPipe, &Overlapped, &dwBytesTransferred, true))
    {
        isSuccess = true;
        if (lpBytesWritten)
        {
            *lpBytesWritten = dwBytesTransferred;
        }
    }

    return isSuccess;
}

bool CNamedPipe::Initialize()
{
    bool isSuccess = false;

    if (m_bInit)
    {
        return true;
    }

    do
    {
        if (nullptr == m_pBuffer)
        {
            m_pBuffer = ::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, PIPE_BUF_MAX_SIZE + sizeof(PIPE_DATA));
        }

        if (nullptr == m_pBuffer)
        {
            break;
        }

        if (NULL == m_hReadEvent)
        {
            m_hReadEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
        }

        if (NULL == m_hReadEvent)
        {
            break;
        }

        if (NULL == m_hWriteEvent)
        {
            m_hWriteEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
        }

        if (NULL == m_hWriteEvent)
        {
            break;
        }

        isSuccess = true;

    } while (false);

    if (!isSuccess)
    {
        Uninitialize();
    }

    m_bInit = isSuccess;

    return m_bInit;
}

void CNamedPipe::Uninitialize()
{
    if (!m_bInit)
    {
        return;
    }

    //关闭管道
    this->Close();

    //释放读写缓冲
    if (nullptr != m_pBuffer)
    {
        ::HeapFree(::GetProcessHeap(), 0, m_pBuffer);
        m_pBuffer = nullptr;
    }

    //关闭事件
    if (m_hReadEvent)
    {
        CloseHandle(m_hReadEvent);
        m_hReadEvent = NULL;
    }

    if (m_hWriteEvent)
    {
        CloseHandle(m_hWriteEvent);
        m_hWriteEvent = NULL;
    }

    m_bInit = false;
}

main.cpp

#include <iostream>
#include "Utils/CNamedPipe.h"
#include <thread>
#include <future>

int main()
{
    std::promise<bool> p;
    std::future<bool> f = p.get_future();

    std::thread(
        [&p]()
        {
            static char szBuf[1024 * 64] = { 0 };
            CNamedPipe pipe;
            if (!pipe.Create(_T("FlameCyclone")))
            {
                std::cout << "Create failed!" << std::endl;
                p.set_value(false);
                return;
            }

            p.set_value(true);

            while (true)
            {
                if (!pipe.WaitConnect())
                {
                    std::cout << "WaitConnect failed!" << std::endl;
                    break;
                }

                while (true)
                {
                    bool isSuccess = pipe.Read(szBuf, sizeof(szBuf));
                    if (isSuccess)
                    {
                        std::cout << "recv: " << szBuf << std::endl;
                    }

                    //另一端断开则重新等待连接
                    if (ERROR_BROKEN_PIPE == ::GetLastError())
                    {
                        pipe.Disconnect();
                        if (!pipe.WaitConnect())
                        {
                            std::cout << "WaitConnect failed!" << std::endl;
                            return;
                        }
                    }
                }
            }
        }
    ).detach();

    if (!f.get())
    {
        return -1;
    }

    CNamedPipe pipe;
    if (!pipe.Open(_T("FlameCyclone"), 5000))
    {
        std::cout << "Open failed!" << std::endl;
        return -1;
    }

    std::string strMsg;

    while (true)
    {
        std::cin >> strMsg;
        std::cout << "send: " << strMsg << std::endl;

        if (!pipe.Write(strMsg.c_str(), strMsg.size() + 1))
        {
            std::cout << "Write failed!" << std::endl;
            break;
        }
    }

    system("pause");
    return 0;
}

 

 

Flame_Cyclone
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
win32-命名管道通信-事件机制-父子进程-C++-Event-启动进程-终止进程-服务器-客户端
插件开发
10-27 429
指向 SECURITY_ATTRIBUTES 结构的指针，该结构指定新命名管道的安全描述符，并确定子进程是否可以继承返回的句柄。) 如果函数失败，则返回值为零， GetLastError 返回除ERROR_IO_PENDING或ERROR_PIPE_CONNECTED以外的值。WaitForSingleObject函数用来检测hHandle事件的信号状态，在某一线程中调用该函数时，线程暂时挂起，如果在挂起的dwMilliseconds毫秒内，线程所等待的对象变为有信号状态，则该函数立即返回；
C++开发基础之命名管道用法详解含示例程序
dotnet研习社
01-22 1901
命名管道（Named Pipe）是一种在操作系统中用于进程间通信的机制。它允许不相关的进程通过共享一个命名的管道来交换数据。命名管道可以在本地计算机上的进程之间进行通信，也可以在不同计算机上的进程之间进行跨网络通信。命名管道的创建和使用类似于传统的匿名管道（Anonymous Pipe），但有一些重要的区别。首先，命名管道是具有唯一名称的，而匿名管道是无名的临时管道。其次，命名管道可以在不同的进程之间进行通信，而匿名管道仅限于父子进程或相关进程之间的通信。
Windows命名管道
fang437385323的专栏
06-09 547
服务端 #include "stdafx.h" #include #define BUFSIZE 1024 const static char* pszPipeName = "\\\\.\\pipe\\mynamedpipe"; int _tmain(int argc, _TCHAR* argv[]) { BOOL bConnected = FALSE; BOOL bSuccess
Win32汇编教程十二 管道操作 (转)
circularr9834的博客
08-12 197
Win32汇编教程十二 管道操作 (转)[@more@]--------------------------------------------------------------------------------在这儿下载本...
命名管道
mycoolx的专栏
01-11 937
以前在学习Linux编程的时候也学过Linux下的命名管道;依稀Linux使用命名管道会创建一个*.fifo的文件，然后使用返回的文件描述符进行操作。具体细节也忘得差不多了。      在Win32的命名令管道和Linux下的命名管道还是很一定程序上的差别，现在也不大记得具体差别有多少。记得好像Linux的命名管道只能在本地计算机中进行通讯（现在不是很确定），Win32的应用程序下却可以应用于网络通讯（类似于套接字）。在这里只记叙Win32命名管道的实现，不作Linux的对比，和Linux相比之下还是有很大
win32命名管道/完成端口用法练习
feihuadao的专栏
10-18 3378
所谓完成端口，就是当事件触发时，io端口操作已完成。 此时完成的是上次执行过的操作，一般是readfile/writefile/waitforconnect。 所以一般的流程是： 添加等待事件->连接成功，readfile(相当于注册回调)。 写动作单独处理。
Win32的管道技术
冷却
06-29 1097
#include #pragma comment(linker,"/subsystem:windows")int WINAPI WinMain( HINSTANCE hInstance, // handle to current instance HINSTANCE hPrevInstance, // handle to previous i
win下命名管道通信压力测试实现的完整c++示例代码
09-13
本示例代码主要展示了如何在C++环境中实现命名管道通信的压力测试，这对于理解和优化多进程或线程间的高效通信至关重要。 首先，我们来了解命名管道的基本概念。命名管道提供了半双工（即单向）通信，但可以通过...
win32-named-pipes-example:使用Win32 API处理命名管道的简单示例代码
04-29
Win32命名管道示例使用Win32 API在C ++中使用命名管道的简单示例代码。 有关完整说明，请参见此处的随附博客文章：作者 。执照该代码可根据MIT开源许可证免费提供（有关详细信息，请参阅随附的LICENSE文件）。 它仅...
命名管道源代码
11-11
在本压缩包中，包含了一系列与实现命名管道相关的C++源代码文件，供学习和参考。以下将详细讲解命名管道的基本概念、工作原理以及通过分析提供的源代码文件可能学习到的关键知识点。 1. 命名管道基本概念： 命名...
windows命名管道通信
03-30
windows命名管道通信,两个进程通过命名管道通信
命名管道的用法，搜集整理于网络
01-20
- **5.2.1 封装kernel32.dll的相关函数**：为了简化开发流程，可以通过封装`kernel32.dll`库中的相关函数来实现命名管道的功能。 - **5.2.2 封装服务器管道的属性和方法**：定义一个类来管理命名管道的各种属性和...
win32 下的串口编程
01-23
1. **打开串口**：使用`CreateFile`函数完成，该函数不仅适用于文件，也涵盖了通信设备、命名管道、邮件槽、磁盘、控制台等对象的创建或打开。对于串口，参数`lpFileName`需指定为如“COM1”的串口逻辑名，`...
Win32汇编教程十二 管道操作
蝈蝈俊.net
12-15 3025
--------------------------------------------------------------------------------在这儿下载本节的所有源程序概述Windows 引入了多进程和多线程机制。同时也提供了多个进程之间的通信手段，包括剪贴板、DDE、OLE、管道等，和其他通信手段相比，管道有它自己的限制和特点，管道实际上是一段共享内存区，进程把共享消息放在那里
WIN32汇编： 21.管道
GodDragon的专栏
06-17 1638
第二十一课 管道这一讲将探索一下管道，看看它是什么、有什么用。为使之更加生动有趣，我将用怎样改变 Edit 控件的背景色和文本颜色来说明此技术。理论：管道，顾名思义就是有两个端的通道。可以使用管道在进程间、同一进程内进行数据交换，就像手提式无线电话机一样。把管道的一端给另一方，他就可以借助管道和你通讯了。有两种管道，即有名管道和匿名管道。匿名管道就是没有名字的管道了，也就是
（五）Win32进程通信 —— 匿名管道
浪子花梦
02-14 875
此案例使用匿名管道，还有一种叫做命名管道，可以百度了解 匿名管道 匿名管道用于进程之间通信，且仅限于本地父子进程之间通信，结构简单，类似于一根非水平状态的水管，一端进水另一端出水（单工）。相对于命名管道，其占用小实现简单。 单管道（匿名管道）实现本例原理图： 思路解析： 在父进程中创建子进程 进程一是父进程，进程二是子进程（可以隐藏) 进程二的输入端正常，将输出端与 hPWrite相连，...
Windows管道 (Pipes)（二）
stevenjoo67的博客
03-19 868
Windows管道
windows命名管道
热门推荐
草上爬的博客
11-17 1万+
一.windows管道简介 管道（Pipe）的定义： A pipe is a section of shared memory that processes use for communication. The process that creates a pipe is the pipe server. A process that connects to a pipe is a pipe
C语言 之 理解指针（1）
最新发布
fallzzzzz的博客
07-20 1194
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
windows C++ 命名管道进程通信序列化
05-11
在 C 语言中，可以使用 Win32 API 提供的相关函数来创建和使用命名管道。命名管道可以用于在同一台机器上的不同进程之间通信，也可以用于网络上的远程进程通信。 在命名管道中进行序列化通信，可以使用类似于 JSON ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值