• C语言_文件_进程_进程间通讯 常用函数/命令 + 实例

    .md带目录版：http://t.csdnimg.cn/jlpQa 

    文件相关命令：

    1. ps -aux|grep init?      //搜索包含init名称的进程
    2. top                     //linux下的资源管理器（动态）
    3.  
    4. //open 返回的int 是给后面的读/写/光标移动 用的fd，没有open就不能进行后面的操作；
    5. int open(const char *pathname, int flags);
    6. int open(const char *pathname, int flags, mode_t mode);
    7. close(fd); //关闭文件
    8.  
    9. // _t 都是返回的int数字；写write，读read，光标移动lseek
    10. ssize_t write(int fd, const void *buf, size_t count);
    11. ssize_t read(int fd, void *buf, size_t count);
    12. off_t lseek(int fd, off_t offset, int whence);
    13.  
    14. //同时打开两个文件
    15. vimdiff demo1.c demo2.c 
    16.  
    17. //fopen注意mode就行，有:r r+ w w+ a ,返回的文件指针是给后面的读 写 偏移用
    18. FILE *fopen(const char *pathname, const char *mode);
    19. fclose(FILE *); //关闭文件
    20.  
    21. //跟上面的差不多一样用
    22. //fread/fwrite(读写的数组,读写的大小,  读写的最大次数?, 读写的文件指针)
    23.                 （读写返回次数的区别：读为有效次数，能一次读完就算你写10次，也返回只读1次）
    24. size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
    25. size_t fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream);
    26. int fseek(FILE *stream, long offset, int whence);
    27.  
    28. fputc();//写入一个字符；
    29. fgetc();//读取一个字符
    30. feof();/检测是否到达文件末尾，到了返回1；文件结束符为EOF=-1;
    31.  
    32. //注意：读写操作都会使光标偏移，但也可以利用这点来遍历读写文件；
    33. 例：
    34. while(!feof(FILE* fd)){
    35.     printf("%c  ",fgetc(FILE* fd));
    36. }

    进程相关命令：

    getpid(); fork(); vfork();

    1.  
    2. //_t 一律返回的是int
    3. //获取进程ID 就是pid
    4. pid_t getpid(void);
    5.  
    6. //fork创建子进程
    7. pid_t fork(void);
    8. //这里返回的是的pid = 0 就是子进程，pid > 0 就是父进程；
    9. //所以可以通过判断pid的值，来区别父子进程需要执行的代码；
    10. //注意fork开辟的子进程，没有等待一说，父子进程谁抢到就先运行谁，
    11. //【子进程为僵尸进程】；
    12. //例：
    13.  
    14. #include
    15. #include 
    16. #include 
    17. #include 
    18. int main()
    19. {
    20.         pid_t pid;
    21.  
    22.         int num = 0;
    23.         pid = getpid();
    24.         printf("this pid:%d\n",getpid());
    25.  
    26.  
    27.         pid_t return_pid = fork();
    28.  
    29.         if(return_pid > 0){
    30.                 while(1){
    31.                 printf("this father pid:%d return_pid:%d \n",getpid(),return_pid);
    32.                 printf("father now num:%d\n",num);
    33.                 sleep(1);
    34.                 }
    35.  
    36.         }else if(return_pid == 0){
    37.  
    38.                 printf("this son pid:%d return_pid:%d \n",getpid(),return_pid);
    39.                 num += 2;
    40.                 printf("child now num:%d\n",num);
    41.                 exit(6);
    42.         }
    43. }
    44.  
    45. //vfork创建子进程
    46. pid_t vfork(void);
    47. //注意fork开辟的子进程，会等待子进程执行完并exit(num)后，父子进程才继续执行，
    48. //【子进程不会成为僵尸进程】；
    49. //例：
    50.  
    51. #include
    52. #include 
    53. #include 
    54. #include 
    55. int main()
    56. {
    57.         pid_t pid;
    58.         pid = getpid();
    59.         printf("this pid:%d\n",getpid());
    60.         int num = 0;
    61.         printf("start_father_num:%d \n",num);
    62.         pid_t return_pid = vfork();
    63.         if(return_pid > 0){
    64.                 while(1){
    65.                         printf("this father pid:%d return_pid:%d \n",getpid(),return_pid);
    66.                         printf("num = %d\n",num);
    67.                         sleep(1);
    68.                 }
    69.         }
    70.         else if(return_pid == 0){
    71.                 int i;
    72.                 for(i=0;i<3;i++){
    73.                         printf("this son pid:%d return_pid:%d \n",getpid(),return_pid);
    74.                         num++;
    75.                         sleep(1);
    76.                 }
    77.                 exit(0);
    78.         }
    79.         return 0;
    80. }
    81.

    exit(6);            wait(status);   WEXITSTATUS(status); 

    子进程退出；  等待子进程； 获取子进程退出状态码；

    1. //wait() 返回的是子进程的ID 即pid；
    2. //里面的 int *status 是子进程的exit(num)的num码；
    3. //后续使用WEXITSTATUS(status),即可打印出来子进程退出时的状态码；
    4. pid_t wait(int *status);
    5. //例：
    6.  
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. int main()
    12. {
    13.         pid_t pid;
    14.         int status = 0;
    15.         pid = getpid();
    16.         printf("start father pid:%d\n",getpid());
    17.         pid_t return_pid = fork();
    18.         if(return_pid > 0 ){
    19.                 pid_t child_pid = wait(&status);
    20.                 printf("\n\nwait_return_childe_pid:%d\n",child_pid);
    21.                 printf("child exit code:%d \n",WEXITSTATUS(status));
    22.                 while(1){
    23.                 printf("this father pid:%d fork_return_pid:%d > 0  \n",getpid(),return_pid);
    24.                 sleep(1);
    25.                 }
    26.                 }else if(return_pid == 0){
    27.                         int i;
    28.                         for(i=0;i<3;i++){
    29.                                 printf("this son pid:%d fork_return_pid:%d == 0 \n",getpid(),return_pid);
    30.                         }
    31.                         exit (6);
    32.                 }
    33.  
    34.  
    35.  
    36.         return 0;
    37. }

    exec组函数 对比 system + popen ：（程序/进程跳转）

    大佬精彩博文： https://blog.csdn.net/u014530704/article/details/73848573

    观后感：

    跟着execl/execlp指定的程序跑了，不回来了！

    1.     //  date 获取时间的程序
    2.     execl("./PATH","date","NULL");
    3.     //  execl(程序所在路径,程序名,结尾必须为NULL)
    4.     //  就像这样用，在当前程序运行到这句代码时，
    5.     //  便将替换为后续执行execl所指的程序，不带回头的那种！
    6.  
    7.     execlp("date","date",NULL);
    8.     //  execlp(程序名,程序名,结尾必须为NULL)
    9.     //  就像这样用，它带p，能自己在环境变量下搜索对应的程序并替换后续执行；
    10.     //  也是不带回头的那种！

    相比较之下 system 执行完指定程序后，还会回来，挺好！

    1.     system("cat demo1.c");
    2.     //执行完成后返回原程序，继续执行后续代码；

    而对比popen 而言，popen除了将指定程序/代码执行完之后，继续执行后续代码外，还将读/写的内容放在管道内，并以文件指针的形式返回；

    1. #include 
    2. #include 
    3. int main()
    4. {
    5.         printf("------------------------------------------------\nPS:\n");
    6.  
    7.         char* p = "ps";
    8.         FILE *fd = popen(p,"r");
    9.         char data[1024];
    10.         fread(&data,1024,1,fd);
    11.         printf("%s\n",data);
    12.         perror("why");
    13.         return 0;
    14. }

    进程间通讯：

    int pipe(int pipefd[2]);  (无名管道，在文件里看不到) 

    里面的fd[2]数组，其中 fd[0] : 读的fd， fd[1] : 写的fd；

    例：通过在父子进程中 close  (fd[0]/fd[1])  配合read(); write(); 实现进程间通讯；

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. int main()
    6. {
    7.         printf("------------------------------------------------:\n");
    8.         int fd[2];
    9.         int n_pipe = pipe(fd);
    10.  
    11.         char data1[128];
    12.         if(n_pipe < 0){
    13.                 printf("error: can not creat pipe!\n");
    14.                 perror("why");
    15.         }
    16.  
    17.         int pid = fork();
    18.         if(pid < 0){
    19.                 printf("error: creat child failed!\n");
    20.                 perror("why");
    21.         }
    22.         if(pid > 0){
    23.                 // sleep(2);
    24.                 printf("this is father pc\n");
    25.                 close(fd[0]);
    26.                 write(fd[1],"hello pipe from father;",strlen("hello pipe from father;"));
    27.                 close(fd[1]);
    28.         }
    29.         if(pid == 0){
    30.                 printf("this is child pc\n");
    31.                 close(fd[1]);
    32.                 read(fd[0],data1,128);
    33.                 printf("data : %s\n",data1);
    34.                 exit(9);
    35.                 }
    36.         return 0;
    37. }

    打印： 

    mkfifo创建有名管道文件；成功返回0；失败返回-1并设置erron = -1；

    返回值判断报错值：EEXIST，可以锁定报错为文件已存在目录中；

    1. /*
    2. int mkfifo(const char *pathname, mode_t mode);
    3. RETURN VALUE
    4.     On success mkfifo() and mkfifoat() return 0.  In the  case  of
    5.     an  error,  -1 is returned (in which case, errno is set appro‐
    6.     priately).
    7.     EEXIST pathname already exists.  This includes the case  where
    8.     pathname is a symbolic link, dangling or not.
    9. */
    10.  
    11. //例：
    12. #include
    13. #include 
    14. #include 
    15. #include 
    16. int main()
    17. {
    18.         if(mkfifo("./demo1.txt",0666) < 0 && errno == EEXIST ){
    19.         printf("mkfifo error:\n");
    20.         perror("why");
    21.     }
    22.     return 0;
    23. }

    mkfifo() 有名管道（会生成临时文件）;  配合 open(); read(); write(); 实现进程间通讯；

    例 mkread +  mkwrite：

    1. //demo mkread：
    2. #include
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. int main()
    10. {
    11.         char buf[30]={0};
    12.         int nff = mkfifo("./demo10.txt",0600);
    13.         if(nff < 0 || errno == EEXIST ){
    14.                 printf("mkfifo error:\n");
    15.                 perror("why");
    16.         }
    17.         if(nff == 0){
    18.                 printf("mkfifo OK! \n");
    19.         }
    20.         int fd = open("./demo10.txt",O_RDONLY);
    21.         printf("open success\n");
    22.  
    23.         int n_read = read(fd,buf,30);
    24.         printf("read %d byte frome fifo context:\n%s\n",n_read,buf);
    25.  
    26.         int n_sys = system("rm ./demo10.txt");
    27.         if(n_sys < 0 || n_sys ==127 ){
    28.                 printf("./demo10.txt delect error! \n");
    29.                 perror("why");
    30.         }else{
    31.                 printf("\n--------------------------------------------");
    32.                 printf("\nsystem: ./demo10.txt delect success !\n");
    33.                 printf("--------------------------------------------\n");
    34.  
    35.         }
    36.  
    37.         close(fd);
    38.         return 0;
    39. }
    1. //demo mkwrite:
    2. #include
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. int main()
    9. {
    10.         char buf[30]={"hello mkfifo file_read/write"};
    11.  
    12.         int fd = open("./demo10.txt",O_WRONLY);
    13.         printf("open success\n");
    14.  
    15.         int n_write = write(fd,buf,strlen(buf));
    16.         printf("write %d byte give fifo context:\n%s\n",n_write,buf);
    17.  
    18.         close(fd);
    19.         return 0;
    20. }

    打印： 

  • 相关阅读:
    ubuntu中执行一个c程序-编辑makefile文件执行make
    大模型的现在进行时：走出对话框，走向产业端
    收银管理软件如何做好员工管理?
    介绍分布式锁
    k8s-kubernetes常用命令，服务部署，可视化控制台安装及token的生成
    flutter系列之:flutter架构什么的,看完这篇文章就全懂了
    常见的Java上机面试题
    使用记录-MongoDB
    tf-lite转换记录
    matlab中的iddata函数的初步理解和使用程序举例
  • 原文地址：https://blog.csdn.net/Wdf_123654/article/details/133994966