首页 > 系统相关 >IO进程day06（进程间通信、信号、共享内存）

IO进程day06（进程间通信、信号、共享内存）

时间：2024-09-01 17:56:44浏览次数：17  
标签：int 间通信 管道 fd IO 进程 include buf

目录

【1】进程间通信 IPC

1》 进程间通信方式

2》 无名管道

1> 特点

2> 函数接口

3> 注意事项

练习：父子进程实现通信，父进程循环从终端输入数据，子进程循环打印数据，当输入quit结束。

3》有名管道

 1> 特点

2> 函数接口

3> 注意事项

 练习：通过两个进程实现 cp功能

 4> 有名管道和无名管道的区别

【2】信号

 1》概念

 2》信号的响应方式

3》信号种类

4》 函数接口

1>  信号发送和挂起

2> 定时器  alarm

3> 信号处理函数 signal()

【3】共享内存

1》特点

 2》步骤

3》 函数接口

4》命令 

【1】进程间通信 IPC

1》 进程间通信方式

（1）早期的进程间通信：

无名管道(pipe)、有名管道(fifo)、信号(signal)

（2）system V PIC：

共享内存(share memory)、信号灯集(semaphore)、消息队列(message queue)

（3）BSD:

套接字(socket)

2》 无名管道

1> 特点

（1）只能用于具有亲缘关系的进程之间的通信

（2）半双工的通信模式，具有固定的读端fd[0]和写端fd[1]。

（3）管道可以看成是一种特殊的文件，对于它的读写可以使用文件IO如read、write函数。

（4）管道是基于文件描述符的通信方式。当一个管道建立时，它会创建两个文件描述符 fd[0]和fd[1]。其中fd[0]固定用于读管道，而fd[1]固定用于写管道。

2> 函数接口

int pipe(int fd[2])

功能：创建无名管道

参数：文件描述符 fd[0]：读端 fd[1]:写端

返回值：成功 0

              失败 -1

#include <stdio.h>
#include <unistd.h>
 
int main(int argc, char const *argv[])
{
    char buf[65536] = "";
    int fd[2] = {0}; //fd[0]代表读端，fd[1]代表写端
    if (pipe(fd) < 0)
    {
        perror("pipe err");
        return -1;
    }
    printf("%d %d\n", fd[0], fd[1]);
 
    //结构类似队列，先进先出
    //1. 当管道中无数据时，读阻塞。
    // read(fd[0], buf, 32);
    // printf("%s\n", buf);
 
    //但是关闭写端就不一样了
    //当管道中有数据关闭写端可以读出数据，无数据时关闭写端读操作会立即返回。
    // write(fd[1], "hello", 5);
    // close(fd[1]);
    // read(fd[0], buf, 32);
    // printf("%s\n", buf);
 
    //2. 当管道中写满数据时，写阻塞，管道空间大小为64K
    // write(fd[1], buf, 65536);
    // printf("full!\n");
    //write(fd[1], "a", 1);  //当管道写满时不能再继续写了会阻塞
 
    //写满一次之后，当管道中至少有4K空间时(也就是读出4K)，才可以继续写，否则阻塞。
    // read(fd[0], buf, 4096); //换成4095后面再写就阻塞了，因为不到4K空间
    // write(fd[1], "a", 1);
 
    //3. 当读端关闭，往管道中写入数据无意义，会造成管道破裂，进程收到内核发送的SIGPIPE信号。
    close(fd[0]);
    write(fd[1], "a", 1);
    printf("read close\n");
 
    return 0;
}

用gdb调试可以看见管道破裂信号:

gcc -g xx.c

gdb a.out

r

3> 注意事项

（1）当管道中无数据时，读操作会阻塞

管道中有数据，将写端关闭，可以将数据读出

管道中无数据，将写端关闭，读操作会立即返回

（2）管道中装满（管道大小64K）数据写阻塞，一旦由 4k 空间，写继续

（3）只有在管道的读端存在时，向管道中写入数据才有意义，否则，会导致管道破裂，向管道中写入数据的进程将收到内核传来的SIGPIPE信号（通常Broken pipe错误）

练习：父子进程实现通信，父进程循环从终端输入数据，子进程循环打印数据，当输入quit结束。

提示：不需要加同步机制, 因为pipe无数据时读会阻塞。

先创建管道再fork，这样父子进程可以使用同一个无名管道。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    char buf[32];//定义一个数组
    int fd[2];//定义两个文件描述符
    if (pipe(fd) < 0)//创建管道并判断
    {
        perror("pipe err\n");
        return -1;
    }
    printf("%d %d\n", fd[0], fd[1]);//打印一下文件描述符
 
    int pid;
    pid = fork();//创建父子进程
    if (pid < 0)//创建失败
    {
        perror("fork err\n");
        return -1;
    }
    else if (pid == 0)//子进程
    {
        while (1)
        {
            read(fd[0], buf, 32);//从读端读取管道中的数据到buf中
            printf("%s\n", buf);//打印buf中的数据
        }
    }
    else//父进程
    {
        while (1)
        {
            scanf("%s", buf);//从终端输入数据到buf中
            if (strcmp(buf, "quit") == 0)//判断输入的是否为 quit，若是，则退出循环
            {
                break;
            }
            write(fd[1], buf, 32);//将 buf 中的数据从写端写到管道中
        }
    }
    return 0;
}

3》有名管道

 1> 特点

（1）有名管道可以使互不相关的两个进程互相通信。

（2）有名管道可以通过路径名来指出，并且在文件系统中可见，但内容存放在内存中。但是读写数据不会存在文件中，而是在管道中。

（3）进程通过文件IO来操作有名管道。

（4）有名管道遵循先进先出规则

（5）不支持如lseek（）操作

2> 函数接口

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

功能：创健有名管道

参数：filename：有名管道文件名

           mode：权限

返回值：成功：0

              失败：-1，并设置errno号

注意对错误的处理方式：

如果错误是file exist时，注意加判断，如：if(errno == EEXIST)

注意：函数只是在路径下创建管道文件，往管道中写的数据依然是写在内核空间中

 练习：

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>//引用错误号头文件

int main(int argc, char const *argv[])
{
    if (mkfifo("./fifo", 0777) < 0)
    {
        if (errno == EEXIST)   //如果错误号信息是已存在则打印提示语句
            printf("file exist!\n");
        else
        {
            perror("mkfifo err");
            return -1;
        }
    }
    printf("mkfifo success\n");

    return 0;
}

3> 注意事项

（1）只写方式打开会阻塞，一直到另一个进程把读端打开

（2）只写方式打开会阻塞，一直到另一个进程把写端打开

（3）可读可写，如果管道中没有数据，读会阻塞

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    char buf[32] = "";
    if (mkfifo("./fifo", 0777) < 0)
    {
        if (errno == EEXIST) // 如果错误号信息是已存在则打印提示语句
            printf("file exist!\n");
        else
        {
            perror("mkfifo err");
            return -1;
        }
    }
    printf("mkfifo success\n");

    // 打开文件
    int fd = open("./fifo", O_RDONLY);//只读方式会阻塞
    // int fd = open("./fifo", O_WRONLY);//只写方式会阻塞
    // int fd = open("./fifo", O_RDWR);//可读可写方式不会阻塞

    // 读写操作
    write(fd, "hello", 5);//向管道写 hello
    read(fd, buf, 32);//从管道中读取数据到buf中
    printf("%s\n", buf);//打印buf中内容
    return 0;
}

 练习：通过两个进程实现 cp功能

一个进程读取源文件中的内容放到管道中，另一个进程读取管道中的内容写到目的文件中

读进程代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    if (mkfifo("./fifo", 0777) < 0) // 创建管道文件
    {
        if (errno == EEXIST)
            printf("fifo exist\n");
        else
        {
            perror("mkfifo err\n");
            return -1;
        }
    }
    printf("fifo success\n");

    int fd, fd1;
    char buf[32];

    // 读
    fd = open("fifo", O_WRONLY);//以只写方式打开管道文件
    fd1 = open(argv[1], O_RDONLY);//以只读方式打开源文件
    int n;//保存读取的数据个数
    //循环读取源文件中的数据，先放到数组buf中，再从buf中读取放到管道中
    while (n = read(fd1, buf, 32))
        write(fd, buf, n);
    
    //关闭文件描述符
    close(fd);
    close(fd1);
    return 0;
}

写进程代码： 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    // 重复执行创建管道操作不会出错，因为当官到文件第一次被创建后，后面在创建不会影响而是会打印 EEXIST 的错误，提示已经存在
    if (mkfifo("./fifo", 0777) < 0) // 创建管道文件
    {
        if (errno == EEXIST)
            printf("fifo exist\n");
        else
        {
            perror("mkfifo err\n");
            return -1;
        }
    }
    printf("fifo success\n");

    int fd, fd2;
    char buf[32];

    // 写
    fd = open("fifo", O_RDONLY);//以只读方式打开管道文件
    fd2 = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0777);//以只写方式打开目的文件
    int n;
    //循环读取管道中的数据，先放到数组buf中，再从buf中读取放到目的文件中
    while (n = read(fd, buf, 32))
        write(fd2, buf, n);

    close(fd);
    close(fd2);
    return 0;
}

 一起执行完毕

 4> 有名管道和无名管道的区别

无名管道有名管道
使用场景具有亲缘关系的进程间不相干的进程间也可以使用
特点

半双工通信

固定的读端fd[0]和写端fd[1]，看做一种特殊的文件可以通过文件操作

在文件系统中会存在管道文件，数据放在内核空间中，通过文件IO进行操作遵循先进先出，不支持lseek操作
函数

pipe(),直接read/write

mkfifo()，先打开open，再读写read/write
读写特性

当管道中无数据会度阻塞

当管道中写满时会写阻塞

关闭读端，往管道中写会管道破裂

只写方式下打开管道会阻塞，直到另一个进程把读端打开

只读方式下打开管道会阻塞，直到另一个进程把写端打开

可读可写方式下打开管道，如果管道中无数据会读阻塞

【2】信号

 1》概念

（1）信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式

（2）信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件

（3）如果该进程当前并未处于执行态，则该信号就又内核保存起来，直到该进程恢复执行再传递给它；如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。

信号的生命周期

 

 2》信号的响应方式

（1）忽略信号：对信号不做任何处理，但是有两个信号不能忽略：即SIGKILL及SIGSTOP.

（2）捕捉信号：定义信号处理函数，当信号发生时，执行相应的处理函数

（3）执行缺省操作：Linux对每种信号都规定了默认操作

3》信号种类

一些比较常用的信号：

SIGINT（2）：中断信号，Ctrl-C 产生，用于中断进程

SIGQUIT（3）：退出信号， Ctrl-\ 产生，用于退出进程并生成核心转储文件

SIGKILL（9）：终止信号，用于强制终止进程。此信号不能被捕获或忽略。

SIGALRM（14）：闹钟信号，当由 alarm() 函数设置的定时器超时时产生。

SIGTERM（15）：终止信号，用于请求终止进程。此信号可以被捕获或忽略。termination

SIGCHLD（17）：子进程状态改变信号，当子进程停止或终止时产生。

SIGCONT（18）：继续执行信号，用于恢复先前停止的进程。

SIGSTOP（19）：停止执行信号，用于强制停止进程。此信号不能被捕获或忽略。

SIGTSTP（20）：键盘停止信号，通常由用户按下 Ctrl-Z 产生，用于请求停止进程。

4》 函数接口

1>  信号发送和挂起

#include <signal.h>

int kill(pid_t pid, int sig);

功能：信号发送

参数：pid：指定进程

           sig：要发送的信号

返回值：成功 0

              失败 -1

int raise(int sig);

功能：进程向自己发送信号

参数：sig：信号

返回值：成功 0

              失败 -1

相当于:kill(getpid(), sig);

int pause(void);

功能：用于将调用进程挂起，直到收到被捕获处理的信号为止。

练习：

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

int main(int argc, char const *argv[])
{
    //kill(getpid(), SIGKILL);  //给进程发送信号，此例子是给当前进程发送SIGKILL信号
    // raise(SIGKILL);  //给当前进程发送SIGKILL信号，等同于kill(getpid(), SIGKILL);  
    // while (1);

    pause();  //将进程挂起，作用类似死循环但是不占用CPU
    return 0;
}

 

2> 定时器  alarm

man 2 alarm

unsigned int alarm(unsigned int seconds)

功能：在进程中设置一个定时器。当定时器指定的时间到了时，它就向进程发送SIGALARM信号。

参数：seconds：定时时间，单位为秒

返回值：如果调用此alarm()前，进程中已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。

注意：一个进程只能有一个闹钟时间。如果在调用alarm时已设置过闹钟时间，则之前的闹钟时间被新值所代替。

常用操作：取消定时器alarm(0)，返回旧闹钟余下秒数。

系统默认对SIGALRM(闹钟到点后内核发送的信号)信号的响应： 如果不对SIGALRM信号进行捕捉或采取措施，默认情况下，闹钟响铃时刻会退出进程。

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

int main(int argc, char const *argv[])
{
    printf("%d\n", alarm(10));  //设定闹钟5秒后发送闹钟信号
    sleep(1);                                       //睡眠1秒，此时闹钟还剩9秒
    printf("%d\n", alarm(3));    //打印剩余的9秒，设新闹钟3秒后发送闹钟信号
    pause(); //为了不让进程结束，等待SIGALRM信号产生，产生之后结束当前进程
    return 0;
}

3> 信号处理函数 signal()

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

功能：信号处理函数

参数：signum：要处理的信号

           handler：信号处理方式

                       SIG_IGN：忽略信号 (忽略 ignore）

                       SIG_DFL：执行默认操作 （默认 default）

                       handler：捕捉信号 (handler为函数名，可以自定义)

void handler(int sig){} //函数名可以自定义, 参数为要处理的信号

返回值：成功：设置之前的信号处理方式

              失败：-1

补充：typedef给数据类型重命名

#include <stdio.h>

//给普通数据类型int重命名
typedef int size4;        

//给指针类型int* 重命名
typedef int *int_p;       

//给数组类型int [10]重命名
typedef int intArr10[10]; 

//给函数指针void (*)()重命名
typedef void (*fun_p)(); 

void fun()
{
    printf("fun\n");
}

int main(int argc, char const *argv[])
{
    size4 a = 10;             //相当于int a=10;
    int_p p = &a;             //相当于int* p=&a;
    intArr10 arr = {1, 2, 3}; //相当于int arr[10]={1,2,3};
    fun_p fp = fun;           //相当于 void (*fp)()=fun;
    printf("%d\n", *p);
    printf("%d\n", arr[0]);
    fp();

    return 0;
}

总而言之，定义变量的变量名写在哪里，用typedef给数据类型重命名的新名字就写在哪里。然后使用新名字定义变量的格式直接就可以为：新名字 变量名;

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

void handler(int sig) //参数sig代表要处理的信号
{
    if (sig == SIGINT)
        printf("ctrl C: %d\n", sig);
    else if (sig == SIGTSTP)
        printf("ctrl Z: %d\n", sig);
}

int main(int argc, char const *argv[])
{
    signal(SIGINT, SIG_IGN);  //对SIGINIT信号设置忽略方式处理
    //signal(SIGINT,SIG_DFL);  //对SIGINIT信号设置缺省方式处理，也就是默认操作
    signal(SIGINT, handler); //对SIGINIT信号设置捕捉方处理，也就是自定义处理方式
    signal(SIGTSTP, handler);

    //while (1); //为了让进程不要结束，因为等到信号真的来才能验证，不然进程就结束了
    pause();  //收到被捕获处理的信号时会结束挂起
    return 0;
}

【3】共享内存

1》特点

（1）共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝。

（2）为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程

将其映射到自己的私有地址空间。进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。

（3）由于多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等

 2》步骤

1> 创建key值

2> 创建或打开共享内存

3> 映射共享内存到用户空间

4> 撤销映射

5> 删除共享内存

3》 函数接口

key_t ftok(const char *pathname, int proj_id);

功能：创建出来的具有唯一映射关系的一个key值，帮助操作系统用来标识一块共享内存

参数：Pathname：已经存在的可访问文件的名字

           Proj_id：一个字符（因为只用低8位）

返回值：成功：key值

              失败：-1

int shmget(key_t key, size_t size, int shmflg);

功能：创建或打开共享内存

参数：key 键值

           size 共享内存的大小

           shmflg IPC_CREAT|IPC_EXCL|0777

返回值：成功 shmid

              出错 -1

注意对错误的处理方式：

如果错误是file exist光打开共享内存不用设IPC_CREAT|IPC_EXCL了，加判断，如：if(errno == EEXIST)

void *shmat(int shmid,const void *shmaddr,int shmflg); //attaches

功能：映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问

参数：shmid 共享内存的id号

           shmaddr 一般为NULL，表示由系统自动完成映射

           如果不为NULL，那么有用户指定

           shmflg：SHM_RDONLY就是对该共享内存只进行读操作

           0 可读可写

返回值：成功：完成映射后的地址，

              出错：-1（地址）

用法：if((p = (char *)shmat(shmid，NULL,0)) == (char *)-1)

int shmdt(const void *shmaddr); //detaches

功能：取消映射

参数：要取消的地址

返回值：成功0

              失败的-1

int shmctl(int shmid,int cmd,struct shmid_ds *buf); //control

功能：(删除共享内存)，对共享内存进行各种操作

参数：shmid 共享内存的id号

           cmd

                    IPC_STAT 获得shmid属性信息，存放在第三参数

                    IPC_SET 设置shmid属性信息，要设置的属性放在第三参数

                    IPC_RMID:删除共享内存，此时第三个参数为NULL即可

           buf shmid所指向的共享内存的地址,空间被释放以后地址就赋值为null

返回值：成功0

              失败-1

用法：shmctl(shmid,IPC_RMID,NULL);

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <errno.h>

int main(int argc, char const *argv[])
{
    int shmid;
    key_t key;
    char *p;
    key = ftok("shm.c", 'a');
    if (key < 0)
    {
        perror("key err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建共享内存
    shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0777); //如果共享内存不存在则创建，存在则返回-1
    if (shmid <= 0)
    {
        if (errno == EEXIST)                //如果共享内存已存在则，直接打开
            shmid = shmget(key, 128, 0777); //直接打开已有的共享内存并且获得共享内存id
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (char *)shmat(shmid, NULL,0);
    if(p == (char *)-1)
    {
        perror("shmat err");
        return -1;
    }

    //操作共享内存
    scanf("%s",p);
    printf("%s\n", p);

    //取消映射
    shmdt(p);

    //删除共享内存
    shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

进程间通信： 

4》命令 

ipcs -m :查看系统中的共享内存

ipcrm -m shmid：删除共享内存

ps: 可能不能直接删除掉还存在进程使用的共享内存。

这时候可以用ps -ef对进程进行查看，kill掉多余的进程后，再使用ipcs查看。

今天的分享就到这里结束啦，如果有哪里写的不好的地方，请指正。
如果觉得不错并且对你有帮助的话点个关注支持一下吧！

标签：int,间通信,管道,fd,IO,进程,include,buf
From： https://blog.csdn.net/dghbs/article/details/141724910

相关文章

  • vue axios
    axios是基于promise的http库，可以用在浏览器和node.js中特性:从浏览器中创建XMLHttpRequests、从node.js创建http请求、支持promiseApi、拦截请求和响应、取消请求、自动转换JSON数据、客户端支持防御xsrfaxios就是一个库，也可以单独独立出来发送ajax。安装： npminstallaxiosa......
  • nginx的location详解
    nginx的location详解属于nginx核心模块中的功能,nginx核心功能.location用于匹配用户请求中的uri的.root/app/code/www/www.oldboylinux.cn         uri:/        /app/code/www/首页文件.www.oldboylinux.cn/index.html   ......
  • [图文直播]基于ZFile和MinIO搭建私有网盘
    前言ZFile以下是ZFile的官网，上面也涉及到了搭建方法https://docs.zfile.vip/install/os-windows此次仅记录本人按照官方的部署方法进行实操验证。下载ibm-semeru-open-jdk_x64_windows_8u372b07_openj9-0.38.0.msizfile-release.jar具体下载地址见上面的官网安装......
  • 【题解】Solution Set - 「蓝」题板刷
    【题解】SolutionSet-「蓝」题板刷始于：2024/9/1（其实之前大概做了十来道，但是没有记录。估计题会比较多，如果从代码里面过来的话，建议直接Ctrl/⌘+F题目名称。「USACO18JAN」MooTubeG2024/9/1一句话题意：https://www.luogu.com/discuss/125319给定一棵有边权的树，每次询......
  • Paper Reading: Multi-class imbalance problem: A multi-objective solution
    目录研究动机文章贡献本文方法问题定义多分类多目标选择集成框架多类样本的客观建模理论分析实验结果数据集和实验设置对比实验结果运行时间优化边界的有效性优点和创新点PaperReading是从个人角度进行的一些总结分享，受到个人关注点的侧重和实力所限，可能有理解不到位的地方。具......
  • python动画教程|Animations using Matplotlib-官网教程程序解读
    随着python学习的深入，我们不可避免进入画图模块matplotlib，也不可避免会遇到制作动画的需求。【1】官网教程如何学习python制作动画，最简单的就是直奔官网：https://matplotlib.org/stable/users/explain/animations/animations.html#animations它给出很长的代码，下面是除引入nu......
  • Lecture 14 A Glimpse of Industrial Solutions
    Lecture14AGlimpseofIndustrialSolutionsTemporalAnti-Aliasing(TAA)为什么有aliasing光栅化期间SPP不足(样本数量不足)终极解决方案是用更多的样本(MSAA)TemporalAnti-Aliasing跨越实际贡献/复用采样思路和在RTRT中如何利用temporal的信息一模一样思路......
  • Lecture 08 & 09 Real-time Global Illumination (screen space)
    Lecture08Real-timeGlobalIllumination(screenspace)GIinScreenSpace只使用屏幕空间的信息换句话说，在现在的渲染结果上做后处理ScreenSpaceAmbientOcclusion(SSAO)为什么要环境光遮蔽容易实现增强场景中的物体和物体间的相对位置（立体感）什么是SSAOAO的......
  • C++ 标准输入输出 -- ＜iostream＞
    <iostream>库是C++标准库中用于输入输出操作的头文件。<iostream>定义了几个常用的流类和操作符，允许程序与标准输入输出设备（如键盘和屏幕）进行交互。以下是<iostream>库的详细使用说明，包括其主要类和常见用法示例。主要类std::istream：用于输入操作的抽象基类。std::ostre......
  • DLL 动态注入---ImgWalk动态库，这个DLL用来检测被注入的进程中当前载入的各个模块名称-
    DLL动态注入—ImgWalk动态库，这个DLL用来检测被注入的进程中当前载入的各个模块名称—exe程序DLL动态注入—ImgWalk动态库，这个DLL用来检测被注入的进程中当前载入的各个模块名称—exe程序文章目录DLL动态注入---ImgWalk动态库，这个DLL用来检测被注入的进程中当前载入......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99