嵌入式第二十四天

最新推荐文章于 2022-08-05 08:35:07 发布
最新推荐文章于 2022-08-05 08:35:07 发布
阅读量188 收藏
点赞数
文章标签： 进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cgj19960119/article/details/81875497
版权


复习： 

进程 ：
父子进程
孤儿进程 
僵尸进程 

进程的状态： 
运行态 
阻塞态 
暂停态 
僵死态 
消亡态 

命令： 
ps aux   查看进程号 
ps -ef   查看进程号
top      查看cpu，内存占用率
pstree   linux倒立的树形结构
bg 1      使程序在后台运行
fg 1      使程序在前台运行
ctrl + c 终止进程
ctrl + z 暂停进程
ctrl + \ 

函数：
getpid();获取子进程的pid   getppid();获取父进程的pid  
fork();  创建子进程
exit();  清理io缓存区并退出   _exit();退出，但是不清理io缓存区
wait(&t);收尸函数，&t存储子进程的返回状态   waitpid(pid,&t,WNOHANG);收尸函数，&t存储子进程pid的返回状态，WNOHANG
不阻塞，0阻塞。
execl();第二个参数以列表的形式写出    execv();第二个参数传递为指针数组   execvp();第一个参数为文件名

指针数组； 是数组。   int *a[3];  |int *|int *|int *|   *a[0]
数组指针： 是指针。 int (*p)[4];

守护进程： 
1. fork();   父进程: exit(0);使父进程脱离终端的控制 
2. setsid();  创建新会话。 脱离进程组，原会话组的控制
3. chdir("/tmp");//创建目录，灵活操作 
4. umask(0);掩码为0，保留子进程继承父进程的权限
5. close(0/1/2);  关闭文件描述符。 关闭标准输入，标准输出，标准错误输出

多进程： 
int main()
{
    int i;
    for(i=0; i<3; i++)
    {
        fork();
    }
}
i=0;   父   子1  
i=1;   子2  子1-1  
i=2;   子3  子1-2 子2-1  子1-1-1


进程间通信： 信号、 管道、 共享内存、消息队列、信号量、 socket套接字

一、 信号    
1. 什么是信号：    在 windows 中，如果无法结束一个进程，可以通过任务处理器结束。 
                同样的功能，在linux和unix中，使用信号这种机制来处理。 
                一个信号的产生叫生成、信号的接收叫捕获。 
                信号：是进程间通信机制中唯一的异步通信机制。 
    
2. 信号的种类： man 7 signal   （kill -l）

        Signal     Value     Action   Comment
       ──────────────────────────
       SIGINT        2       Term    ctrl + c  中断信号
       SIGQUIT       3       Core    ctrl + \  终止进程信号
       SIGILL        4       Core    非法指令
       SIGABRT       6       Core    abort 函数产生的终止信号 
       SIGFPE        8       Core    浮点异常 
       SIGKILL       9       Term    必杀
       SIGSEGV      11       Core    段错误 -- 地址非法使用 
       SIGPIPE      13       Term    管道破裂
       SIGALRM      14       Term    闹钟信号 
       SIGTERM      15       Term    kill 产生的信号 
       SIGCHLD   20,17,18    Ign     子进程终止后，会向父进程发送此信号 
       SIGTSTP   18,20,24    Stop    ctrl + z 将一个运行着的进程扔到后台，并暂停

3. 信号处理方式
1) 捕获信号  signal(SIGINT,fun);  /当SIGINT 信号被捕获，执行 fun 函数。  
2) 忽略信号  signal(SIGTSTP,SIG_IGN);  
3) 默认处理  signal(SIGILL,SIG_DFL);


4. 处理信号的函数：  signal
函数原型：        typedef void (*sighandler_t)(int); // 将 sighandler_t 这个指针，typedef 成为一个类型：函数指针类型。 
                sighandler_t signal(int signum, sighandler_t handler);
头文件：          #include <signal.h>
参数：           参数一： 指定信号代码。 
              参数二： 对于信号的处理方式。
返回值：  函数指针
功能：    对信号做处理。 信号处理函数。 
说明： typedef void (*sighandler_t)(int); 
    void (*sighandler_t)(int);  这是一个函数指针的定义。 定义的指针名为 sighandler_t. 
    当这个定义前，加上 typedef ，这个指针就不再是一个指针，而是重定义成类型名了。
    所以得到的结论是： sighandler_t 是一个类型名。 可以用它来定义此种类型的变量。 

示例： 

#include <stdio.h>
#include <signal.h>
void fun(int sig_num)
{
    switch(sig_num)
    {
    case SIGINT:
        printf("lalala ~\n");
        break;
    case SIGTSTP:
        printf("hello world!\n");
        break;
    case SIGQUIT:
        printf("I'm a teacher\n");
        break;
    default:
        break;
    }
    return;
}
int main()
{
    signal(SIGINT,fun);
    signal(SIGTSTP,fun);
    signal(SIGQUIT,fun);
    while(1);
    return 0;
}

//练习：编写程序 向数组中输入数据 当收到信号(SIGINT)时 统计出数组中元素的个数 sleep(1);  
#include <stdio.h>
#include <signal.h>
int count = 0;
void fun(int sig_num)
{
    printf("count : %d\n",count+1);
    return ;
}
int main()
{
    signal(SIGINT,fun);
    int a[1000] = {0};
    for(count=0; count<1000; count++)
    {
        a[count] = 66;
        sleep(1);
    }
    return 0;
}

5. raise
函数原型： int raise(int sig);
参数：   信号的编号。 
功能： 只能给自己发送信号。 
返回值： 成功 0 
         失败 -1 

6. 发送信号的函数：   kill
函数原型：    int kill(pid_t pid, int sig);
头文件：        #include <sys/types.h>
                #include <signal.h>
参数；  参数一： pid  > 0   发送信号给 进程号为 pid 的这个进程。 
                 pid  == 0  发送信号给进程组的所有进程。 
                 pid  == -1  发送信号给除了init 的所有进程。 
                 pid  < -1  发送信号给进程组号为 -pid 的每一个进程。 
        参数二： sig: 信号类型。 
返回值： 成功： 0 
         失败： -1 
示例：
文件1：sig.c
#include <stdio.h>
#include <signal.h>
void fun(int sig_num)
{
    printf("I'm not afraid of you\n");
    return;
}
int main()
{
    printf("%d\n",getpid());
    signal(SIGINT,fun);
    while(1);
    return 0;
}
//文件2： kill.c 
#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
int main(int argc,char *argv[])
{
    int pid = atoi(argv[1]); //将传递过来的字符串转换为整型。 
    kill(pid,SIGINT);
    return 0;
}
//
执行过程： 
1) gcc sig.c    
2) gcc kill.c -o mykill  
3) ./a.out   //等信号  
4) ./mykill 15678  //给进程号为 15678 的这个进程发送信号。  


7. 闹钟信号函数：  alarm
函数原型：   unsigned int alarm(unsigned int seconds);
头文件：     #include <unistd.h>
参数：     seconds 无符号整型的秒数。 经过 seconds 秒，发送 SIGALRM 信号。 
返回值：   如果之前设置过时间，本次会返回上次设置时间后，剩余的秒数。
           如果之前没有设置过时间，则返回 0 。 
示例：
/// 
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
void fun(int s)
{
    printf("Time out !\n");
    return ;
}
int main()
{
    signal(SIGALRM,fun);
    alarm(5);
    int i;
    for(i=0; i<10; i++)
    {
        printf("Hello\n");
        sleep(1);
    }
    return 0;
}

//练习：测试分钟打字速度
1 随机产生字符  rand()%26+'a'
2 signal(SIGALRM,fun)
//
#include <signal.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
int count = 0;
void fun(int signum)
{
    printf("Your speed is %d\n",count*3);
    exit(0);
}
int main()
{
    srand(time(0));
    signal(SIGALRM,fun);
    alarm(20);
    char c,input;
    while(1)
    {
        c = rand()%26 + 'a';
        printf("%c\n",c);
        input = getchar();
        getchar();
        if(input == c)
            count ++;
    }
}


    管道 
二、 无名管道 
1. 创建管道函数：  pipe  
描述符：int pfd[2];    pfd[0]:读端   pfd[1]:写端
函数原型：  int pipe(int pipefd[2]);
头文件：    #include <unistd.h>
参数：   文件描述符。
返回值： 成功： 0 
         失败： -1 
特点：  
1） 半双工通信           
2） 无名管道，只能用在有亲缘关系的进程之间。 
3） 不是文件。不属于任何文件系统，只存在于内存中。 
4） 只要管道中信息被读取，被读取的内存就释放。可以继续存放数据。
5） 管道传输信息时，没有类型。 所以双方在读写时，要事先约定好类型。 

示例： 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
    int pfd[2];
    int ret = pipe(pfd);
    if(ret < 0)
    {
        perror("pipe");
        exit(-1);
    }
    pid_t id = fork();
    if(id < 0)
    {
        perror("fork");
        exit(-1);
    }
    else if(id == 0)
    {
        sleep(2);
        close(pfd[1]);
        int n;
        read(pfd[0],&n,sizeof(n));
        close(pfd[0]);
        printf("%d \n",n);
    }
    else 
    {
        close(pfd[0]);
        int num;
        puts("input a num:");
        scanf("%d",&num);
        write(pfd[1],&num,sizeof(num));
        close(pfd[1]);
        wait(NULL);

    }
    return 0;
}

//练习：父进程从键盘获取一个字符串 传递给子进程 
子进程 收到串后 转为大写 在输出到屏幕

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
void change(char *p)
{
    while(*p)    //直到字符串结束。 
    {
        if(*p >= 'a' && *p <= 'z')   //如果在小写字母范围。 换成大写 。
            *p = *p - 'a' + 'A';
        p++;
    }
    return ;
}
int main()
{
    int pfd[2];
    int ret = pipe(pfd);    //先创建管道。 
    if(ret < 0)
    {
        perror("pipe");
        exit(-1);
    }
    pid_t id = fork();   //然后创建进程。 
    if(id < 0)
    {
        perror("fork");
        exit(-1);
    }
    else if(id == 0)         //子进程  
    {
        sleep(2);
        close(pfd[1]);     //关闭写端。 
        char string[100] = "\0";
        read(pfd[0],string,sizeof(string));   //读取信息到变量中。 
        close(pfd[0]);
        change(string);         //大小写转换。 
        printf("%s \n",string);   //输出最终结果。 
    }
    else 
    {
        close(pfd[0]);       //关闭读端。 
        char buf[100] = {0};
        puts("input a string:");
        gets(buf);                   
        write(pfd[1],buf,sizeof(buf));   //向管道文件中写内容。 
        wait(NULL);
    }
    return 0;
}


三 有名管道：
1. 创建有名管道：  mkfifo  
函数原型：        int mkfifo(const char *pathname, mode_t mode);
头文件：   #include <sys/types.h>
           #include <sys/stat.h>
参数：     参数一： 管道文件所在路径，一直写到管道文件名称。 
           参数二： 管道文件的权限。 
返回值：   成功： 0 
           失败： -1 

2. 删除文件： unlink  
函数原型：        int unlink(const char *pathname);
头文件：      #include <unistd.h>
参数：       pathname ： 管道文件所在路径,一直要写到管道文件名字结束。 
返回值：    成功： 0 
            失败： -1

3. 步骤： 
1） mkfifo  
2） open 
3） read/write 
4） close  
5） unlink 

4. 与无名管道的区别： 
a. 有名管道是个管道文件。 
b. 有名管道可以用在任意两个进程之间。这两个进程不必有亲缘关系。 

示例：
write.c   
//
#include "my.h"    
int main()
{
    int ret = mkfifo("./myfifo",0664);
    if(ret < 0)
    {
        perror("mkfifo");
        exit(-1);
    }
    int fd = open("./myfifo",O_WRONLY);
    if(fd < 0)
    {
        perror("open");
        exit(-1);
    }
    int n = 122;
    write(fd,&n,sizeof(n));
    close(fd);
    return 0;
}
read.c 
///
#include "my.h"
int main()
{
    int fd = open("./myfifo",O_RDONLY);
    if(fd < 0)
    {
        perror("open");
        exit(-1);
    }
    int n;
    read(fd,&n,sizeof(n));
    printf("n = %d \n",n);
    close(fd);
    unlink("./myfifo");
    return 0;
}
///
执行过程： 
1） gcc write.c -o w  
2） gcc read.c -o r 
3） ./w     (有可能在阻塞等待)
4） ./r     读取文件信息。 


//练习：使用有名管道，进行进程间通信。 进程1从键盘获取一个字符串 传递给子进程 
进程2 收到串后 转为大写 在输出到屏幕

三个文件： 
create.c   (功能：创建有名管道)
//
#include <stdio.h>
int main(int argc,char *argv[])
{
    if(argc < 2)
    {
        printf("%s fifo_name\n",argv[0]);
        return 0;
    }
    int ret = mkfifo(argv[1],0664);
    if(ret < 0)
    {
        perror("mkfifo");
        return -1;
    }
    printf("OK\n");
    return 0;
}

write.c 
///
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char *argv[])
{
    if(argc < 2)
    {
        printf("%s  <fifo_name>\n",argv[0]);
        return -1;
    }
    int fd = open(argv[1],O_WRONLY);
    char buf[100] = {0};
    puts("input a string:");
    gets(buf);  
    write(fd,buf,sizeof(buf));
    close(fd);
    return 0;
}

read.c 
//
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
void change(char *p)
{
    while(*p)
    {
        if(*p >= 'a' && *p <= 'z')
            *p = *p - 'a' + 'A';    
        p++;
    }
    return ;
}
int main(int argc,char *argv[])
{
    if(argc < 2)
    {
        printf("%s <fifo_name>\n",argv[0]);
        return -1;
    }
    int fd = open(argv[1],O_RDONLY);
    char string[100] = "\0";
    read(fd,string,sizeof(string));
    close(fd);
    change(string);
    printf("%s \n",string);
    return 0;
}
//
执行过程: 
gcc create.c -o creat  
gcc write.c -o w 
gcc read.c -o r 
./creat fifo
./w     fifo        （写入数据，如果空间不足，阻塞写）
./r     fifo      读取数据。 

//练习： 进程1，向管道中写一个学生信息： struct worker，进程2 读信息。
struct worker 
{
    char name[30];
    int age;
    float salary;
};

answer:   4 files 
(1) my.h
/
#ifndef _MY_H_ 
#define _MY_H_  1

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

typedef struct{
    char name[30];
    int age;
    float salary;
}worker_t;

#endif /* _MY_H_ */

(2)
create.c 
//
#include <stdio.h>
int main(int argc,char *argv[])
{
    if(argc < 2)
    {
        printf("%s fifo_name\n",argv[0]);
        return 0;
    }
    int ret = mkfifo(argv[1],0664);
    if(ret < 0)
    {
        perror("mkfifo");
        return -1;
    }
    printf("OK\n");
    return 0;
}

(3) write.c 
/
#include "my.h"
int main(int argc,char *argv[])
{
    if(argc < 2)
    {
        printf("%s  <fifo_name>\n",argv[0]);
        return -1;
    }
    int fd = open(argv[1],O_WRONLY);

    worker_t w; 
    puts("input your name age salary:");
    scanf("%s%d%f",w.name,&w.age,&w.salary);  
    write(fd,&w,sizeof(w));
    close(fd);
    return 0;
}

(4) read.c 
//
#include "my.h"
int main(int argc,char *argv[])
{
    if(argc < 2)
    {
        printf("%s <fifo_name>\n",argv[0]);
        return -1;
    }
    int fd = open(argv[1],O_RDONLY);
    worker_t w;
    read(fd,&w,sizeof(w));
    close(fd);
    unlink(argv[1]);
    printf("%s :--> %d %.2f \n",w.name,w.age,w.salary);
    return 0;
}
//
执行过程： 
gcc create.c -o creat 
gcc write.c -o write 
gcc read.c -o read  
./creat myfifo 
./write myfifo 
./read myfifo 


//作业：实现有名管道版本的cat：
    write.c 将磁盘文件中的数据  传递给进程read.c  
    read.c 将文件内容输出到屏幕

    


 

不为人知的小小鸟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2 Open/Close函数及touch命令的实现
wenwen111111的专栏
02-25 1579
1. input & output：站在应用层考虑 Input：内核-->用户，从内核读取数据或从文件读取数据 ————read函数 Output：用户-->内核，写数据到内核或写数据到文件中 ————write函数 2. 内核中文件太多了，写到哪个文件，从哪个文件中读呢？这些功能由内核管理，又称文件管理。 因此read/write时需要有参数指定某个文件，而且在read/writ
第十四届蓝桥杯嵌入式省赛
02-23
"第十四届蓝桥杯嵌入式省赛"是针对这一技术进行的专业竞赛，旨在考察参赛者的嵌入式系统设计与应用能力。 一、嵌入式系统基础 嵌入式系统是指以应用为中心，以计算机技术为基础的，软硬件可裁剪的专用计算系统。它...
嵌入式Linux驱动：不能多次close(fd)
sandalphon4869的博客
04-29 2742
文章目录一、问题二、解决 一、问题 驱动程序 // buffer数组的最大长度 #define RWBUF_MAX_SIZE 1024 // 设备中存储信息的全局结构体指针 typedef struct Data { // 用于打开和释放的验证，0表示未使用，1表示已使用 int count; // 表示字符串 char buffer[RWBUF_MAX_SI...
嵌入式Linux文件IO，标准IO和文件IO的区别,文件描述符，open()函数,close()函数
m0_37542524的博客
11-02 883
每个打开的文件都对应一个文件描述符 文件描述符是一个非负整数。 Linux为程序中每个打开的文件分配一个文件描述符 文件描述符从0开始分配， 依次递增。 文件IO操作通过文件描述符来完成 当程序运行的时候，系统会默认打开3个流：标准输入、标准输出、标准错误，所对应的文件描述符分别是0、1、2 #include &amp;lt;fcntl.h&amp;gt; int open(const char *path, int oflag, …); #include &amp;l
嵌入式学习之linux系统编程---3 文件IO之close函数
qq_42822743的博客
03-15 2380
1、close函数的函数原型 #include <unistd.h>; int close(int fd); 该函数的作用是：关闭一个文件描述符。fd就是文件描述符。 在ubuntu界面输入“man 2 close”即可查看close函数的相关信息，“2”是指close在man手册的第2页。 2、思考：close函数里面的fd参数是怎么来的呢？ 首先，每一个文件都有文件描述符与之对应的；文件描述符是打开文件之后由系统给我们分配的；当我们关闭一个文件时，我们使用的fd是从open这个系统调用里面返
linux 关闭popen 打开的命令
w18mc0431的专栏
08-05 4719
程序设计了一个图形界面用于开了一个线程执行终端命令，通过pope打开一个管道来执行命令， 此时需要循环读取程序执行的结果。 void* command_exec(void* cmdstr) {      FILE *cmdStream=NULL;         char *cmd = (char *)cmdstr;          char buff[200];      i
第十三届蓝桥杯嵌入式程序设计
04-21
本资源摘要信息旨在对第十三届蓝桥杯嵌入式程序设计竞赛项目进行总结和分析。该项目旨在考察选手的嵌入式程序设计和开发能力，要求选手使用大赛组委会提供的四梯/国信长天嵌入式竞赛实训平台，完成程序设计和调试。 ...
第十一届蓝桥杯嵌入式省赛真题第二部分
02-22
"蓝桥杯嵌入式设计与开发项目省赛第二部分" 本资源为蓝桥杯嵌入式省赛第二部分试题，旨在考察选手的嵌入式设计与开发能力。本试题共有四部分：基本要求、硬件框图、功能描述和其他要求。 基本要求 在本试题中，...
蓝桥杯嵌入式省赛 第十三届 客观题目 真题
01-06
【嵌入式系统特点】 嵌入式系统是专门针对特定应用而设计的计算机系统，其特点包括：采用专用微控制器，这意味着它们通常基于定制的处理器芯片，而非通用的CPU；软硬件协同一体化设计，强调软件与硬件的紧密结合，以...
嵌入式系统马维华第三版课程十章ppt讲义
12-15
第二章“嵌入式处理器”深入探讨了嵌入式系统的核心——处理器。这包括微控制器、DSP（数字信号处理器）和SoC（系统级芯片）等不同类型的处理器，以及它们的架构、指令集和性能指标，帮助学生理解如何选择合适的...
管道实例
rangf的专栏
08-24 554
#include #include #include #include #include #include int main(void) {   int nCount=0,i,flag=1;   int pfd[2];   char szBuffi[1] = {0};   char szBuffo[1] = {0};   int  status;   pid_
Linux网络编程6——poll和epoll
HuanBianCheng27的博客
08-05 2146
select 出来的比较早，其缺点是监听散乱的文件描述符效率会低一点。所以使用 poll，但是 poll 效率没改进多少，所以又改进为 epoll。
无名管道实现cat | grep
Poseidon's Maserati
09-08 499
shell命令的本质是一个个封装好的c函数，同样由基本系统调用编写。 相当于shell行输入:cat /etc/passwd | grep root,需要任何过滤功能，只需要将传入字符串改变即可。 /************************************************************************* &gt; File Name: cmd...
无名管道和有名管道的概念与实现
wzm10455的专栏
01-16 2044
1.管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道； 2.只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）； 3.单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。 4.数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的
嵌入式Linux管道函数使用实例,linux系统中管道的介绍和线程同步代码示例
weixin_35731754的博客
05-08 271
传统的进程间通信其中有无名管道(PIPE)、有名管道(FIFO)和信号(Signal)。咱们今天就说说linux中基于POSIX的有名管道(FIFO)和无名管道(PIPE)。1. 描述：管道提供一个单向的进程间通讯通道。一个管道，有一个读端和一个写端。写到写端的数据能从这个管道的读端读出。无名管道，在linux中可以通过pipe2函数来创建一个无名管道，执行这个函数后，会返回两个文件描述符，一个指...
exec与文件描述符
Kaiwii的专栏
03-05 1453
在*nux系统中，一般在操作文件时会直接使用文件名，在支持POSIX的各种环境中，提供了一系列用于操作文件的工具，短小精悍却又强大得变态。在shell环境下，还经常文件描述符（正整数）来操作文件。 系统默认打开的描述符有3个：     0   - 标准输入     1   - 标准输出     2   - 标准出错 所以，只要够斯文（别整太大的数，它不仅难记，而且你不需要），几乎所有的正
Linuxc 进程间通信之有名管道
qq_37192076的博客
05-25 1200
利用有名管道文件实现进程间通信，要求1.写进程向有名管道文件写入10次“hello world”；2.读进程读取有名管道文件中的内容，并依次打印。源代码：w.c#include &lt;fcntl.h&gt;#include &lt;sys/types.h&gt;#include &lt;sys/stat.h&gt;#include &lt;stdlib.h&gt;#include &lt;std...
嵌入式Linux管道函数使用实例,linux有名管道通信实验
weixin_35912164的博客
05-08 421
1．实验目的通过编写有名管道多路通信实验，进一步掌握管道的创建、读写等操作，同时复习使用select()函数实现管道的通信。2．实验内容这里采用管道函数创建有名管道(并不是在控制台下输入命令)，而且使用select()函数替代poll()函数实现多路复用(使用select()函数是出于以演示为目的)。3．实验步骤(1)画出流程图。该实验流程图如图1所示。图1 实验流程图(2)编写代码。该实验源代码...
【Linux~有名管道间实现cat功能~服务端，客户端收发文件】
weixin_43151932的博客
11-01 433
蓝桥杯嵌入式第十四届
最新发布
04-13
蓝桥杯嵌入式第十四届是中国著名的计算机竞赛之一，专注于嵌入式系统开发。以下是关于蓝桥杯嵌入式第十四届的介绍： 1. 时间和地点：蓝桥杯嵌入式第十四届比赛通常在每年的春季举行，具体时间和地点会根据组织方的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值