Linux下C++进程间通信机制

最新推荐文章于 2024-07-05 15:57:20 发布
最新推荐文章于 2024-07-05 15:57:20 发布
阅读量1.6k 收藏 8
点赞数 2
分类专栏： C++ 多进程编程 文章标签： c++ linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chixipeng/article/details/106003972
版权

linux下进程间通信的几种主要手段简单简介：

  1. 管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；
  2. 信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数 sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal 函数）；
  3. 进程信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。
  4. 消息队列（Message）：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。
  5. 共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
  6. 套接字（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。

一.管道通信方式：

管道通信具有单向，无结构，先进先出的字节流特点;管道有2个端点，一个端点写入数据，一个端点读取数据，当数据从管道中读出时，这些数据将被移走。当进程从空管道中读取数据或向已满的管道写入数据时，进程将被挂起，直到有进程向管道中写入数据或从管道中读取数据，此时，进程将由等待状态变为就绪状态。对管道的操作和对文件的操作差不多。根据管道提供的应用接口的不同，管道可分为命名管道和无名管道。

1、无名管道：

#include <unistd.h>

int pipe(int fd[2])  ；      

 创建一个无名管道fd包含2个文件描述符的数组，fd[0]用于读，fd[1]用于写若成功返回0,否则反回-1

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

//一般某个进程用于读，另一个进程用于写，用于读的进程需要close(fd[1]),用于写的进程需要close(fd[0]);
int main(void)
{
    pid_t pid;
    int fd[2],i,n;
    char chr;
    pipe(fd);
    pid=fork();
    if(pid==0)          //子进程
    {
        close(fd[1]);
        for(i=0;i<10;i++)
        {
            read(fd[0],&chr,1);
            printf("%c\n",chr);
        }
        close(fd[0]);
        exit(0);
    }
    close(fd[0]);           //父进程
    for(i=0;i<10;i++)
    {
        chr='a'+i;
        write(fd[1],&chr,1);
        sleep(1);
    }
    close(fd[1]);
    return 0;
}

2、命名管道：

#include <sys/types.h>

#include <sys/stat.h>

int mkfifo(const char *pathname,mode_t mode);

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
    mkfifo("fifo",0660);   //创建一个命令管道，属主和用户组具有读写权限
    pid_t pid;
    pid=fork();
    if(pid==0)
    {
        char buf[256];
        int fd=open("fifo",O_RDONLY);   //子进程读管道中的数据
        read(fd,buf,10);
        buf[10]=0;
        printf("%s",buf);
        close(fd);
        exit(0);
    }
    int fd=open("fifo",O_WRONLY);    //父进程向管道写入数据
    write(fd,"fifo test\n",10);
    close(fd);
    return 0;
}

 

二、信号量(用与多进程程序在存取共享资源时的同步控制）——System V

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

1、int semget(key_t key,int nsems,int semflg)   //获得或创建信号量，成功返回信号量标识，出错返回-1

key：根据key生成信号量标识；

nsems：创建的信号量集中的信号量的个数，该参数只在创建信号量集时有效；

semflg：存取权限或创建条件若为0则用于获得已存在的信号量，若为IPC_CREAT|perm perm为存取权限，则用于创建信号量；

2、int semop(int semid,struct sembuf* sops,unsigned nsops)  //获得或者释放信号量，成功返回0,否则返回-1

semid:信号量标识；

sops指向由sembuf组成的数组；

nsops信号量的个数；

struct sembuf{

ushort sem_num;   //在信号量数组中的索引

short sem_op;       //要执行的操作,若sem_op大于0那么操作为将sem_op加入到信号量的值中，并唤醒等待信号增加的进程;若sem_op等于0,当信号量的值也是0时， 函数返回，否则阻塞直到信号量的值为0；若sem_op小于0,则判断信号量的值加上sem_op的值，如果结果为0,唤醒等待信号量为0的进程，如果小于0，调用该函数的进程阻塞，如果大于0,那么从信号量里减去这个值并返回。

short sem_flg;         //操作标致，SEM_UNDO会阻塞，IPC_NOWAIT不会阻塞

};

3、int semctl(int semid,int semnum,int cmd,union semun arg); //在信号量集上的控制操作

semid信号量集的标识；

semnum信号量集的第几个信号量，撤销信号量集时，次参数可缺省；

cmd用于指定操作类别，值为GETVAL获得信号量的值，SETVAL设置信号量的值，GETPID获得最后一次操作信号量的进程，GETNCNT获得正在等待信号量的进程数，GETZCNT获得等待信号量值变为0的进程数，IPC_RMID 删除信号量或信号量数组

三、消息队列

消息队列是存在于内核中的消息列表，一个进程可以将消息发送到消息列表。另一个进程可以从消息列表接受消息。消息队列的操作方式为先进先出

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/msg.h>

1、int msgget(key_t key,int msgflg)

函数说明:功能:获取或者创建一个消息队列，key值同上，msgflg：存取或者创建条件值同上。成功返回消息队列标识，失败返回-1.

2、int msgsnd(int msgid,const void* msgp,size_t msgsz,int msgflg)

函数说明:功能:向消息队列中发送消息，msgid:消息队列标识，msgp消息结构体的地址，msgsz:消息结构体的字节，msgflg:操作标志，成功返回0,否则返回-1。在消息队列没有足够的空间容纳发送的消息时，该函数会阻塞，如果msgflg为IPC_NOWAIT ，则不管发送消息是否成功，该函数都不会阻塞。其中msgp必须指向这样一个结构体

struct msgbuf{

long mtype;   //必须有且大于0

char mtext[1];  //这个可以自己定以，也可以定义其他成员

}

3、size_t msgrcv(int msgid,void *msgp,size_t msgsz,long msgtyp,int msgflg)

函数说明:获取指定消息队列中，msgtyp类型的消息，该值要根发送消息的结构体中msgp->mtype值一样，msgsz，消息结构体的大小，msgflg操作标志，值同上

成功返回收到的字节个数，失败返回-1

4、int msgctl(int msqid,int cmd,struct msqid_ds* buf)

函数说明:cmd操作类型，IPC_RMID删除消息队列，IPC_STAT获取消息队列的状态，IPC_SET改变消息队列的状态，buf用来存放消息队列的属性信息，其结构体如下

struct msqid_ms{

struct ipc_perm msg_perm;   //权限

struct msg *msg_first;　　　//消息队列的首

struct msg *msg_last;  　　 //消息队列的尾

__kernel_time_t msg_stime;   //最后发送时间

__kernel_time_t msg_rtime;  //最后接受时间

__kernel_time_t msg_ctime; //最后修改时间

unsigned short msg_cbytes;    //当前消息队列的字节数

unsigned short msg_qnum;  //消息队列中的消息数

unsigned short msg_qbytes; //消息队列的最大字节数

__kernel_ipc_pid_t  msg_lspid; //最后发送消息的进程ID

__kernel_ipc_pid_t  msg_lrpid; //最后接受消息的进程ID

};

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#define MSG_KEY 111
#define BUFSIZE 4096
struct msgbuf
{
    long mtype;
    char mtext[BUFSIZE];
};
int main()
{
    int mspid;
    pid_t pid;

    mspid=msgget(MSG_KEY,IPC_CREAT|0666);
    if(mspid==-1)
    {
        perror("msgget");
        exit(-1);
    }

    pid=fork();
    if(pid<0)
    {
        perror("fork");
        exit(-1);
    }
    else if(pid==0)
    {
        sleep(10);
        int msqid=msgget(MSG_KEY,0);
        if(msqid==-1)
        {
            perror("msgget");
            exit(-1);
        }
        struct msgbuf buf;
        if(msgrcv(msqid,(void *)&buf,sizeof(struct msgbuf),1,0)==-1)
        {
            perror("msgrcv");
            exit(-1);
        }
        printf("child:rcv a msg is %s\n",buf.mtext);
        exit(0);
    }
    else
    {
        struct msgbuf buf;
        buf.mtype=1;
        strcpy(buf.mtext,"Hello World!");
        if(msgsnd(mspid,(const void *)&buf,sizeof(struct msgbuf),0)==-1)
        {
            perror("msgsnd");
            exit(-1);
        }
        printf("parent:snd a msg is %s\n",buf.mtext);
        sleep(10);
    }

   // struct msqid_ds cbuf;
    msgctl(mspid,IPC_RMID,NULL);
    return 0;
}

 

四、共享内存

共享内存是内核中的一块存储空间，这块内存被映射至多个进程的虚拟地址空间。共享内存在不同进程虚拟地址空间中映射地址未必相同。

#include <sys/ipc.h>

 #include <sys/shm.h>

1、int shmget(key_t key,int size,int shmflg)

函数说明：功能：创建或获得共享内存，key：作用同上，size：共享内存的大小，shmflg:存取权限或创建条件，若为IPC_CREAT|perm perm为存取权限，则表示创建共享内存，为0表示获得共享内存

2、void * shmat(int shmid,const void *shmaddr,int shmflg)

函数说明:功能：将创建的共享内存映射到进程虚拟地址空间的某个位置，shmid：共享内存标识，shmaddr要映射到的进程虚拟空间地址，若为NULL，则由系统决定对应的地址，shmflg：指定如何使用共享内存，若指定了SHM_RDONLY位则表示以只读的方式使用此段，否则以读写的方式使用此段.成功返回映射的地址失败返回-1

3、int shmdt(const void* shmaddr);

函数说明：解除共享内存的映射，shmaddr:共享内存的映射地址，成功返回0,否则返回-1

4、int shmctl(int shmid,int cmd,struct shmid_ds *buf)

函数说明：对以存在的共享内存进行操作，shmid：共享内存标识，cmd：操作类型：cmd 为IPC_STAT 获取共享内存的状态，IPC_/SET设置共享内存的权限,IPC_RMID删除共享内存，IPC_LOCK 锁定共享内存，使共享内存不被置换出去，IPC_UNLOCK解锁。

　　　　struct shmid_ds{

　　　　struct ipc_perm 　　shm_perm;   //存取权限

　　　　int　　　　　　　　shm_segsz; //共享内存大小

　　　　__kernel_time_t       shm_atime;  //最后映射时间

 　　　  __kernel_time_t       shm_dtime;  //最后解除映射时间

　　　　__kernel_time_t       shm_ctime;  //最后修改时间

　　　　__kernel_ipc_pid_t  shm_cpid;    //创建进程ID

　　　　__kernel_ipc_pid_t  shm_lpid;    //最近操作进程ID

　　　　unsigned short         shm_nattch; //建立映射的进程数

　　　　}

下面是一个经典的生产者消费者代码实例，通过信号量和共享内存实现：

//semshm.h 封装了创建信号量删除信号量，P操作，V操作

#ifndef SEMSHM_H
#define SEMSHM_H

#define SHM_KEY 9494
#define SEM_KEY_1 9399
#define SEM_KEY_2 9595
#define BUF_SIZE 1024
#include <string.h>
union semnum
{
    int     val;
    struct semid_ds *buf;
    unsigned short  *array;
};

int sem_create(key_t key,int val)   //创建一个信号量并置处值为val
{
    int semid;
    semid=semget(key,1,0666|IPC_CREAT);
    if(semid==-1)
    {
        perror("semget");
        exit(-1);
    }
    union semnum arg;  //联合类型的变量初始化必须用{}，赋值使用 arg.val=0
    arg.val=val;         //设信号量的初始值
    if(semctl(semid,0,SETVAL,arg)==-1)
    {
        perror("semctl");
        exit(-1);
    }
    return semid;
} 
void sem_del(int semid)   //删除信号量
{
    union semnum arg;
    arg.val=0;
    if(semctl(semid,0,IPC_RMID,arg)==-1)
    {
        perror("semctl");
        exit(-1);
    }
}

int P(int semid)  //P操作，使信号量的值减1
{
    struct sembuf sops={0,-1,SEM_UNDO};//第三个参数设置为SEM_UNDO时当信号量小于0时会阻塞，设置为IPC_NOWAIT则不会阻塞
    return (semop(semid,&sops,1));
    
}

int V(int semid)  //V操作，使信号量的值加一
{
    struct sembuf sops={0,+1,SEM_UNDO};
    return (semop(semid,&sops,1));
}

struct msg_data         //定义一个共享内存存储的消息结构体
{
    char data[BUF_SIZE];
};

void Productor(struct msg_data *msg,int i)  //生产者
{
    const char * str="productid:";
    char *array[]={"1","2","3","4","5"};
    strcpy(msg->data,str);
    strcat(msg->data,array[i]);
    printf("Productor:%s\n",msg->data);
}

void Customer(struct msg_data *msg)     //消费者
{
    printf("Customer:%s\n",msg->data);
}
#endif

 

//allsemshm.c   创建了2个信号量用于实现生产者和消费者之间的同步问题 ，并创建了一个共享内存作为共享资源

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include "semshm.h"
int main()
{
    int empty,full,shmid;
    empty=sem_create(SEM_KEY_1,1);//设置一个信号量置初值为1
    full=sem_create(SEM_KEY_2,0); //设置一个信号量置初值为0
    shmid=shmget(SHM_KEY,sizeof(struct msg_data),0666|IPC_CREAT);
    if(shmid==-1)
    {
        perror("shmget");
        exit(-1);
    }

    printf("empty=%d\tfull=%d\tshmid=%d\n",empty,full,shmid);
    return 0;
}

 

//semshm_s.c  生产者代码

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include "semshm.h"

int main()
{
    int empty,full,shmid;
    empty=semget(SEM_KEY_1,1,0);    //获得信号量
    full=semget(SEM_KEY_2,1,0);
    shmid=shmget(SHM_KEY,0,0);      //获得共享内存
    if(empty==-1||full==-1||shmid==-1)
    {
        perror("get");
        exit(-1);
    }

    struct msg_data *buf;
    void * tmp=shmat(shmid,NULL,0);  //映射共享内存
    buf=(struct msg_data*)tmp;
    int i=0;
    for(i=0;i<5;i++)
    {
        sleep(15);
        P(empty);      
        Productor(buf,i);　　　　//生产者向共享内存写入数据
        V(full);
    }
    return 0;
}
//semshm_c.c  消费者代码 

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include "semshm.h"


int main()
{
    int empty,full,shmid;
    empty=semget(SEM_KEY_1,1,0);   //获取信号量
    full=semget(SEM_KEY_2,1,0);
    shmid=shmget(SHM_KEY,0,0);     //获取共享内粗
    if(empty==-1||full==-1||shmid==-1)
    {
        perror("get");
        exit(-1);
    }

    struct msg_data *buf;
    buf=(struct msg_data*)shmat(shmid,NULL,0);   //映射共享内存地址
    int i=0;
    for(i=0;i<5;i++)
    {
        P(full);
        Customer(buf);           //消费者从共享内存取数据
        V(empty);
    }

    
    return 0;
}
//delsemshm.c  //删除所建的信号量和共享内存    

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include "semshm.h"
int main()
{
    int empty,full,shmid;
    empty=semget(SEM_KEY_1,1,0);
    full=semget(SEM_KEY_2,1,0);
    shmid=shmget(SHM_KEY,0,0);
    if(empty==-1||full==-1||shmid==-1)
    {
        perror("del get");
        exit(-1);
    }
    sem_del(empty);
    sem_del(full);
    struct shmid_ds *ds=(struct shmid_ds*)malloc(sizeof(struct shmid_ds));
    shmctl(shmid,IPC_RMID,ds);
    printf("del success !\n");
    return 0;
}

参考链接：https://blog.csdn.net/hamlee67/article/details/84777440

醉如泥
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++进阶（应用篇）——第二章 进程间的通信
Bing_bing_bing_的博客
09-27 6831
2.进程间的通信 2.1进程 本章讲解windows平台下，进程间的通信方式。 进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动，是操作系统动态执行的基本单元。简单的说，进程就是一段程序的执行过程。 进程和线程：进程是系统动态执行的基本单位，也是系统分配资源的基本单位；线程是进程中执行的最小单位，它可以访问进程的共享资源。 进程之间对共享内存等进行读写操作，需要使用互斥机制...
linux 进程间通信
11-17
Demo是实现进程间通信的实例当前大型进程间通信都是以本Demo为例实现的 本代码通过测试无误直接贴过去就能运行Linux下 SYSTEM V
vc++中进程间的通信
07-06 1122
进程通常被定义为一个正在运行的程序的实例，它由两个部分组成：　　一个是操作系统用来管理进程的内核对象。内核对象也是系统用来存放关于进程的统计信息的地方　　另一个是地址空间，它包含所有的可执行模块或DLL模块的代码和数据。它还包含动态分配的空间。如线程堆栈和堆分配空间。每个进程被赋予它自己的虚拟地址空间，当进程中的一个线程正在运行时，该线程可以访问只属于它的进程的内存。属于其它进程的内存则是隐藏的，
C++ 多进程多线程间通信
最新发布
wy749929317的博客
07-05 881
请注意，这里的互斥锁是在全局命名空间中创建的（通过前缀"Global\\"），这意味着它可以在系统范围内的任何进程中访问。这是必需的，因为我们的目标是让多个不同的进程能够识别并访问同一个互斥锁。请注意，我们使用了全局命名的信号量（通过前缀Global\），这意味着信号量在整个系统中都是可见的，可以被任何进程访问。特点：它是最快的进程间通信方式，避免了数据的拷贝，但共享内存需要解决并发访问和同步问题，常用的同步机制包括互斥锁（Mutexes）、信号量（Semaphores）和事件（Events）等。
浅学C++(6)Linux环境编程(进程间通信)
weixin_45700807的博客
09-05 907
Linux系统下的进程间通信的介绍 使用内存映射、MSG系列函数实现进程间通信
Linux c/c++进程间通信(1)
ShiXiAoLaNga的博客
03-07 1483
1. 进程间通信的概念 进程间通信是指不同的进程之间进行信息的传递 1. 同一主机上的进程通信 父子进程之间 非父子进程之间 2.不同主机上的进程通信(网络通信) 2. 普通文件通信 父子进程之间可以直接通过文件描述符号(fd)直接进行通信 示例: 父进程写文件,子进程读取文件 #include <stdio.h> #include <s...
linux下的C\C++多进程多线程编程实例详解
09-15
### Linux下的C/C++多进程多线程编程实例详解 #### 一、多进程编程 在Linux环境下，多进程编程是实现并发处理的一种常见方法。通过`fork()`系统调用，我们可以创建一个新的进程，该进程几乎复制了父进程的所有属性...
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
04-03
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
进程间通信sample
04-24
在这个“进程间通信sample”项目中，开发者使用了Linux系统下的信号量（Semaphore）来实现进程间的同步与互斥，从而确保对共享资源的正确访问。 信号量是一种同步原语，它是一个计数器，可以用来控制多个进程对共享...
linux进程间通信.pdf
08-19
### Linux进程间通信详解 #### 一、进程间通信概述 进程间通信（Inter-Process Communication，简称IPC）是指在不同的进程之间交换数据或者协调进程的行为。Linux操作系统提供了多种进程间通信的方式，使得进程间...
c++进程间通信程序
03-24
此代码为c++进程间通信的一个完整实例，代码编译后就可以运行，通过这个实例，可以掌握c++进程间的通信知识
操作系统的进程同步问题 C++代码
06-13
单处理机的情况下用优先权的调度策略实现处理机调度
C++进程间通信
L_qingting的博客
07-10 3070
多进程是指在一个程序中同时运行多个独立的进程，每个进程都有自己的独立的内存空间和执行环境。进程间通信是指不同进程之间进行数据交换和共享资源的方式。
C++ 进程间通信
weixin_45596153的博客
03-30 282
一，C++ 常用进程间通信 管道(Pipe)：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。 命名管道(named pipe)：命名管...
c++进程间通信
weixin_35750483的博客
12-26 328
C 语言中的进程间通信方式有多种，包括共享内存、消息队列、信号量、套接字等。 共享内存是指多个进程可以访问同一块内存，从而实现进程间的通信。共享内存的优点是速度快，但实现较为复杂，需要自己维护同步机制以避免冲突。 消息队列是一种异步的进程间通信方式，允许一个进程向队列中发送消息，另一个进程从队列中接收消息。消息队列可以在进程之间传递任意类型的消息，不过需要注意的是，消息队列的大小是有限的，超过限制...
C++ 进程间通信一
lbjayo的专栏
02-11 578
最直接也最实用的方法 我感觉用 WM_COPYDATA消息实现进程间数据共享 最直接，当然也最实用 实现进程间数据共享除了常用的内存文件映射外，对于一些非文件的数据共享可以直接使用消息WM_COPYDATA。 如果需要在进程A传递数据到进程B，简单的实现如下： 在进程A中： CString strDataToSend = _T( "Hello" );   //需要传递的数据 HWND
进程间通信（CC++）
ajdjirkdnkfk的博客
11-29 277
进程间通信（C/C++） // 无名管道 #include <stdio.h> #include <unistd.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> #include <fcntl.h> int main() { int fd[2]; // 创建无名管道 int ret = pipe(fd); if (ret < 0)
C/C++：进程间通信
weixin_63790642的博客
09-18 959
进程间通信（Inter-Process Communication，IPC）是指不同的进程之间进行数据交换和通信的机制。进程间通信允许多个独立运行的进程协同工作以完成某个任务或共享信息。pipewriteread不同的 IPC 方法适用于不同的应用场景和需求。选择适当的 IPC 方法取决于进程之间的关系、通信频率、数据传输量以及其他特定要求。在设计和实现应用程序时，需要仔细考虑IPC机制以确保正确的数据传输和进程协作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值