3、Linux程序设计入门--文件操作

最新推荐文章于 2024-07-24 09:58:58 发布
最新推荐文章于 2024-07-24 09:58:58 发布
阅读量606 收藏
点赞数
分类专栏： linux程序设计之c基础教程（转） 文章标签： linux buffer struct file socket 数据结构

Linux下文件的操作
前言:
我们在这一节将要讨论linux下文件操作的各个函数.
文件的创建和读写
文件的各个属性
目录文件的操作
管道文件

----------------------------------------------------------------------------

文件描述符用来表示一个打开的文件，文件描述符是一个非负整数。一般程序中默认打开了的文件描述符为   

0：STDIN_FILENO，

1:  STDOUT_FILENO，

2：STDERR_FILENO

1、文件的创建和读写
       我假设你已经知道了标准级的文件操作的各个函数(fopen,fread,fwrite等等).当然如果你不清楚的话也不要着急.我们讨论的系统级的文件操作实际上是为标准级文件操作服务的.
当我们需要打开一个文件进行读写操作的时候,我们可以使用系统调用函数open.使用完成以后我们调用另外一个close函数进行关闭操作.
[cpp]  view plain copy
  1. #include <fcntl.h>  
  2. #include <unistd.h>  
  3. #include <sys/types.h>  
  4. #include <sys/stat.h>  
  5.   
  6. int open(const char *pathname,int flags);  
  7. int open(const char *pathname,int flags,mode_t mode);  
  8. int close(int fd);  


open函数有两个形式.其中pathname是我们要打开的文件名(包含路径名称,缺省是认为在当前路径下面).flags可以去下面的一个值或者是几个值的组合.
O_RDONLY: 以只读的方式打开文件.
 O_WRONLY:以只写的方式打开文件.
 O_RDWR:     以读写的方式打开文件.
 O_APPEND: 以追加的方式打开文件.
 O_CREAT:   创建一个文件.
 O_EXEC:     如果使用了O_CREAT而且文件已经存在,就会发生一个错误.
 O_NOBLOCK:以非阻塞的方式打开一个文件.
 O_TRUNC:     如果文件已经存在,则删除文件的内容.
        前面三个标志只能使用任意的一个.如果使用了O_CREATE标志,那么我们要使用open的第二种形式.还要指定mode标志,用来表示文件的访问权限.mode可以是以下情况的组合.
-----------------------------------------------------------------
S_IRUSR 用户可以读 S_IWUSR 用户可以写
 S_IXUSR 用户可以执行 S_IRWXU 用户可以读写执行
-----------------------------------------------------------------
S_IRGRP 组可以读 S_IWGRP 组可以写
 S_IXGRP组可以执行 S_IRWXG 组可以读写执行
-----------------------------------------------------------------
S_IROTH其他人可以读 S_IWOTH 其他人可以写
 S_IXOTH 其他人可以执行 S_IRWXO 其他人可以读写执行
-----------------------------------------------------------------
S_ISUID 设置用户执行ID S_ISGID 设置组的执行ID
-----------------------------------------------------------------
        我们也可以用数字来代表各个位的标志.Linux总共用5个数字来表示文件的各种权限.00000.第一位表示设置用户ID.第二位表示设置组ID,第三位表示用户自己的权限位,第四 位表示组的权限,最后一位表示其他人的权限.每个数字可以取1(执行权限),2(写权限),4(读权限),0(什么也没有)或者是这几个值的和
..
       比如我们要创建一个用户读写执行,组没有权限,其他人读执行的文件.设置用户ID位那么我们可以使用的模式是--1(设置用户ID)0(组没有设置)7(1+2+4)0(没有权限,使用缺省)  5(1+4)即10705:open("temp",O_CREAT,10705);
      如果我们打开文件成功,open会返回一个文件描述符.我们以后对文件的所有操作就可以对这个文件描述符进行操作了.
当我们操作完成以后,我们要关闭文件了,只要调用close就可以了,其中fd是我们要关闭的文件描述符.
文件打开了以后,我们就要对文件进行读写了.我们可以调用函数read和write进行文件的读写. 
#include <unistd.h>
ssize_t read(int fd, void *buffer,size_t count);
ssize_t write(int fd, const void *buffer,size_t count);

     fd是我们要进行读写操作的文件描述符,buffer是我们要写入文件内容或读出文件内容的内存地址.count是我们要读写的字节数.
对于普通的文件read从指定的文件(fd)中读取count字节到buffer缓冲区中(记住我们必须提供一个足够大的缓冲区),同时返回count.

如果read读到了文件的结尾或者被一个信号所中断,返回值会小于count.

如果是由信号中断引起返回,而且没有返回数据,read会返回-1,且设置errno为EINTR.

当程序读到了文件结尾的时候,read会返回0.

          write从buffer中写count字节到文件fd中,成功时返回实际所写的字节数.
下面我们学习一个实例,这个实例用来拷贝文件.
[cpp]  view plain copy
  1. #include <unistd.h>  
  2. #include <fcntl.h>  
  3. #include <stdio.h>  
  4. #include <sys/types.h>  
  5. #include <sys/stat.h>  
  6. #include <errno.h>  
  7. #include <string.h>  
  8. #define BUFFER_SIZE 1024  
  9. int main(int argc,char **argv)  
  10. {  
  11.     int from_fd,to_fd;  
  12.     int bytes_read,bytes_write;  
  13.     char buffer[BUFFER_SIZE];  
  14.     char *ptr;  
  15.     if(argc!=3)  
  16.     {  
  17.         fprintf(stderr,"Usage:%s fromfile tofile/n/a",argv[0]);  
  18.         exit(1);  
  19.     }  
  20.     /* 打开源文件 */  
  21.     if((from_fd=open(argv[1],O_RDONLY))==-1)  
  22.     {  
  23.          fprintf(stderr,"Open %s Error:%s/n",argv[1],strerror(errno));  
  24.          exit(1);  
  25.     }  
  26.     /* 创建目的文件 */  
  27.     if((to_fd=open(argv[2],O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))==-1)  
  28.     {  
  29.          fprintf(stderr,"Open %s Error:%s/n",argv[2],strerror(errno));  
  30.          exit(1);  
  31.      }  
  32.     /* 以下代码是一个经典的拷贝文件的代码 */  
  33.      while(bytes_read=read(from_fd,buffer,BUFFER_SIZE))  
  34.     {  
  35.          /* 一个致命的错误发生了 */  
  36.          if((bytes_read==-1)&&(errno!=EINTR))   
  37.              break;  
  38.          else if(bytes_read>0)  
  39.          {  
  40.               ptr=buffer;  
  41.               while(bytes_write=write(to_fd,ptr,bytes_read))  
  42.              {  
  43.                   /* 一个致命错误发生了 */  
  44.                   if((bytes_write==-1)&&(errno!=EINTR))break;  
  45.                   /* 写完了所有读的字节 */  
  46.                   else if(bytes_write==bytes_read) break;  
  47.                   /* 只写了一部分,继续写 */  
  48.                   else if(bytes_write>0)  
  49.                   {  
  50.                        ptr+=bytes_write;  
  51.                        bytes_read-=bytes_write;  
  52.                   }  
  53.                }  
  54.                /* 写的时候发生的致命错误 */  
  55.                if(bytes_write==-1)break;  
  56.            }  
  57.       }  
  58.       close(from_fd);  
  59.       close(to_fd);  
  60.       exit(0);  
  61. }  


2、文件的各个属性
      文件具有各种各样的属性,除了我们上面所知道的文件权限以外,文件还有创建时间,大小等等属性.
有时侯我们要判断文件是否可以进行某种操作(读,写等等).这个时候我们可以使用access函数.
[cpp]  view plain copy
  1. #include <unistd.h>  
  2.   
  3. int access(const char *pathname,int mode);  
pathname:是文件名称；mode是我们要判断的属性.可以取以下值或者是他们的组合.

R_OK文件可以读,

W_OK文件可以写

X_OK文件可以执行,

F_OK文件存在.

当我们测试成功时,函数返回0,否则如果有一个条件不符时,返回-1.

如果我们要获得文件的其他属性,我们可以使用函数stat或者fstat.
[cpp]  view plain copy
  1. #include <sys/stat.h>  
  2. #include <unistd.h>  
  3. int stat(const char *file_name,struct stat *buf);  
  4. int fstat(int filedes,struct stat *buf);  
  5. struct stat {  
  6.        dev_t    st_dev; /* 设备 */  
  7.        ino_t    st_ino; /* 节点 */  
  8.        mode_t   st_mode; /* 模式 */  
  9.        nlink_t  st_nlink; /* 硬连接 */  
  10.        uid_t    st_uid; /* 用户ID */  
  11.        gid_t    st_gid; /* 组ID */  
  12.        dev_t    st_rdev; /* 设备类型 */  
  13.        off_t    st_off; /* 文件字节数 */  
  14.        unsigned long st_blksize; /* 块大小 */  
  15.        unsigned long st_blocks; /* 块数 */  
  16.        time_t   st_atime; /* 最后一次访问时间 */  
  17.        time_t   st_mtime; /* 最后一次修改时间 */  
  18.        time_t   st_ctime; /* 最后一次改变时间(指属性) */  
  19. };  
      stat用来判断没有打开的文件,而fstat用来判断打开的文件.我们使用最多的属性是st_mode.通过着属性我们可以判断给定的文件是一个普通文件还是一个目录,连接等等.可以使用下面几个宏来判断.

S_ISLNK(st_mode): 是否是一个连接.

S_ISREG   是否是一个常规文件.

S_ISDIR    是否是一个目录

S_ISCHR  是否是一个字符设备.

S_ISBLK   是否是一个块设备

S_ISFIFO  是否 是一个FIFO文件.

S_ISSOCK  是否是一个SOCKET文件. 

我们会在下面说明如何使用这几个宏的.

3、目录文件的操作
在我们编写程序的时候，有时候会要得到我们当前的工作路径。C库函数提供了getcwd来解决这个问题。
[cpp]  view plain copy
  1. #include <unistd.h>  
  2.   
  3. char *getcwd(char *buffer,size_t size);  

我们提供一个size大小的buffer,getcwd会把我们当前的路径考到buffer中.如果buffer太小,函数会返回-1和一个错误号.
Linux提供了大量的目录操作函数,我们学习几个比较简单和常用的函数.
[cpp]  view plain copy
  1. #include <dirent.h>  
  2. #include <unistd.h>  
  3. #include <fcntl.h>  
  4. #include <sys/types.h>  
  5. #include <sys/stat.h>  
  6. int mkdir(const char *path,mode_t mode);  
  7. DIR *opendir(const char *path);  
  8. struct dirent *readdir(DIR *dir);  
  9. void rewinddir(DIR *dir);  
  10. off_t telldir(DIR *dir);  
  11. void seekdir(DIR *dir,off_t off);  
  12. int closedir(DIR *dir);  
  13. struct dirent {  
  14.    long d_ino;  
  15.    off_t d_off;  
  16.    unsigned short d_reclen;  
  17.    char d_name[NAME_MAX+1]; /* 文件名称 */  

mkdir              很容易就是我们创建一个目录,

opendir      打开一个目录为以后读做准备.

readdir      读一个打开的目录.

rewinddir   是用来重读目录的和我们学的rewind函数一样.

closedir     是关闭一个目录.

telldir和seekdir类似与ftee和fseek函数.

        下面我们开发一个小程序,这个程序有一个参数.如果这个参数是一个文件名,我们输出这个文件的大小和最后修改的时间,如果是一个目录我们输出这个目录下所有文件的大小和 修改时间.
[cpp]  view plain copy
  1. #include <unistd.h>  
  2. #include <stdio.h>  
  3. #include <errno.h>  
  4. #include <sys/types.h>  
  5. #include <sys/stat.h>  
  6. #include <dirent.h>  
  7. #include <time.h>  
  8. static int get_file_size_time(const char *filename)  
  9. {  
  10.    struct stat statbuf;  
  11.    if(stat(filename,&statbuf)==-1)  
  12.    {  
  13.       printf("Get stat on %s Error:%s/n",  
  14.       filename,strerror(errno));  
  15.       return(-1);  
  16.     }  
  17.     if(S_ISDIR(statbuf.st_mode))  
  18.        return(1);  
  19.     if(S_ISREG(statbuf.st_mode))  
  20.        printf("%s size:%ld bytes/tmodified at %s",filename,statbuf.st_size,ctime(&statbuf.st_mtime));  
  21.   
  22.      return(0);  
  23. }  
  24. int main(int argc,char **argv)  
  25. {  
  26.     DIR *dirp;  
  27.     struct dirent *direntp;  
  28.     int stats;  
  29.     if(argc!=2)  
  30.     {  
  31.        printf("Usage:%s filename/n/a",argv[0]);  
  32.        exit(1);  
  33.     }  
  34.     if(((stats=get_file_size_time(argv[1]))==0)||(stats==-1))  
  35.         exit(1);  
  36.     if((dirp=opendir(argv[1]))==NULL)  
  37.     {  
  38.         printf("Open Directory %s Error:%s/n",argv[1],strerror(errno));  
  39.         exit(1);  
  40.     }  
  41.     while((direntp=readdir(dirp))!=NULL)  
  42.     {      
  43.         if(get_file_size_time(direntp-<d_name)==-1)  
  44.         break;  
  45.     }  
  46.     closedir(dirp);  
  47.     exit(1);  
  48. }  
4、管道文件
       Linux提供了许多的过滤和重定向程序,比如more cat等等.还提供了< > | <<等等重定向操作符.在这些过滤和重 定向程序当中,都用到了管道这种特殊的文件.系统调用pipe可以创建一个管道.
[cpp]  view plain copy
  1. #include<unistd.h>  
  2.   
  3. int pipe(int fildes[2]);  
pipe调用可以创建一个管道(通信缓冲区).当调用成功时,我们可以访问文件描述符fildes[0],fildes[1].其中fildes[0]是用来读的文件描述符,而fildes[1]是用来写的文件描述符.
在实际使用中我们是通过创建一个子进程,然后一个进程写,一个进程读来使用的.
关于进程通信的详细情况请查看进程通信
[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <string.h>  
  5. #include <errno.h>  
  6. #include <sys/types.h>  
  7. #include <sys/wait.h>  
  8. #define BUFFER 255  
  9. int main(int argc,char **argv)  
  10. {  
  11.     char buffer[BUFFER+1];  
  12.     int fd[2];  
  13.     if(argc!=2)  
  14.     {  
  15.         fprintf(stderr,"Usage:%s string/n/a",argv[0]);  
  16.         exit(1);  
  17.     }  
  18.     if(pipe(fd)!=0)  
  19.     {  
  20.         fprintf(stderr,"Pipe Error:%s/n/a",strerror(errno));  
  21.         exit(1);  
  22.     }  
  23.     if(fork()==0)  
  24.     {  
  25.         close(fd[0]);  
  26.         printf("Child[%d] Write to pipe/n/a",getpid());  
  27.         snprintf(buffer,BUFFER,"%s",argv[1]);  
  28.         write(fd[1],buffer,strlen(buffer));  
  29.         printf("Child[%d] Quit/n/a",getpid());  
  30.         exit(0);  
  31.      }  
  32.      else  
  33.      {  
  34.         close(fd[1]);  
  35.         printf("Parent[%d] Read from pipe/n/a",getpid());  
  36.         memset(buffer,'/0',BUFFER+1);  
  37.         read(fd[0],buffer,BUFFER);  
  38.         printf("Parent[%d] Read:%s/n",getpid(),buffer);  
  39.         exit(1);  
  40.       }  
  41. }  
为了实现重定向操作,我们需要调用另外一个函数dup2.
[cpp]  view plain copy
  1. #include <unistd.h>  
  2.   
  3. int dup2(int oldfd,int newfd);  
       dup2将用oldfd文件描述符来代替newfd文件描述符,同时关闭newfd文件描述符.也就是说,所有向newfd操作都转到oldfd上面.下面我们学习一个例子,这个例子将标准输出重定向 到一个文件.
[cpp]  view plain copy
  1. #include <unistd.h>  
  2. #include <stdio.h>  
  3. #include <errno.h>  
  4. #include <fcntl.h>  
  5. #include <string.h>  
  6. #include <sys/types.h>  
  7. #include <sys/stat.h>  
  8. #define BUFFER_SIZE 1024  
  9. int main(int argc,char **argv)  
  10. {  
  11.     int fd;  
  12.     char buffer[BUFFER_SIZE];  
  13.     if(argc!=2)  
  14.     {  
  15.          fprintf(stderr,"Usage:%s outfilename/n/a",argv[0]);  
  16.          exit(1);  
  17.     }  
  18.     if((fd=open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1)  
  19.     {  
  20.          fprintf(stderr,"Open %s Error:%s/n/a",argv[1],strerror(errno));  
  21.          exit(1);  
  22.     }  
  23.     if(dup2(fd,STDOUT_FILENO)==-1)  
  24.     {  
  25.           fprintf(stderr,"Redirect Standard Out Error:%s/n/a",strerror(errno));  
  26.           exit(1);  
  27.     }  
  28.     fprintf(stderr,"Now,please input string");  
  29.     fprintf(stderr,"(To quit use CTRL+D)/n");  
  30.     while(1)  
  31.     {  
  32.           fgets(buffer,BUFFER_SIZE,stdin);  
  33.           if(feof(stdin))  
[cpp]  view plain copy
  1.               break;  
  2.           write(STDOUT_FILENO,buffer,strlen(buffer));  
  3.      }  
  4.      exit(0);  
  5. }  

好了,文件一章我们就暂时先讨论到这里,学习好了文件的操作我们其实已经可以写出一些比较有用的程序了.我们可以编写一个实现例如dir,mkdir,cp,mv等等常用的文件操作命令了.想不想自己写几个试一试呢?

补充函数：

scandir函数：读取特定的目录数据
表头文件：#include <dirent.h>
定义函数：int scandir(const char *dir, struct dirent **namelist, int (*select) (const struct dirent *), int (*compar) (const struct dirent **, const struct dirent**));
函数说明： scandir()会扫描参数dir指定的目录文件，经由参数select指定的函数来挑选目录结构至参数namelist数组中，最后再调用参数compar指定的函数来排序namelist 数组中的目录数据。每次从目录文件中读取一个目录结构后便将此结构传给参数select所指的函数， select函数若不想要将此目录结构复制到namelist数组就返回0，若select为空指针则代表选择所有的目录结构。scandir()会调用 qsort()来排序数据，参数compar则为qsort()的参数，若是要排列目录名称字母则可使用alphasort(). 结构dirent定义请参考readdir()
返回值 ：成功则返回复制到namelist数组中的数据结构数目，有错误发生则返回-1
错误代码：ENOMEM 核心内存不足

stat函数：读取指定文件的属性

表头文件:    #include <sys/stat.h>
                     #include <unistd.h>
定义函数:    int stat(const char *file_name, struct stat *buf);
函数说明:    通过文件名filename获取文件信息，并保存在buf所指的结构体stat中
返回值:      执行成功则返回0，失败返回-1，错误代码存于errno

stat详细

判断文件属性的几个宏：

     S_ISLNK(st_mode):   是否是一个连接.
     S_ISREG                      是否是一个常规文件.
     S_ISDIR                        是否是一个目录

     S_ISCHR                      是否是一个字符设备.
     S_ISBLK                       是否是一个块设备
     S_ISFIFO                      是否是一个FIFO文件.

     S_ISSOCK                    是否是一个SOCKET文件

ll2323001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统编程作业：UNIX Shell and History Feature
OrdinaryCrazy的博客
04-25 4756
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;unistd.h&gt; #include &lt;sys/types.h&gt; #include &lt;sys/shm.h&gt; #include &lt;wait.h&gt; #include &lt;string.h&gt; #include &lt;
Linux入门教程之Linux的基本操作-综合文档
05-21
Linux入门教程之Linux基本操作是针对初学者设计的一份综合文档，旨在帮助新手熟悉这个开源操作系统的基础使用方法。Linux作为一种强大的、广泛应用于服务器和开发环境的操作系统，其强大的命令行工具和灵活的文件...
Linux下文件编程实验
weixin_34029949的博客
01-15 158
这部分不难但很重要 ，涉及到以后的驱动程序。主要有三个知识点系统调用、C语言库函数访问文件和时间编程。 （1）创建文件 #include<stdio.h>#include<stdlib.h>#include<sys/types.h>#include<sys/stat.h>#include&...
笔记4 linux文件编程
JoyHuangJunjie的博客
05-03 352
一、文件编程可使用两种：1、linux系统调用2、c语言库函数1、系统调用 ① int creat(const char* filename,mode_t mode) filename ----------包含路径 ：/home/joy/hello.c mode ---------------S_IRUSR(1) S_IWUS...
linux文件IO底层读写操作
正版冒雨
08-24 2495
1.底层文件访问。          运行中的程序成为进程，每个进程都有与之关联的文件描述符。       文件描述符 － 一些小值整数，通过他们访问打开的文件或设备。开始运行会有三个文件描述符： 0:   标准输入   STDIN_FILENO 1:   标准输出   STDOUT_FILENO 2:   标准错误   STDERR_FILENO       文件描述符的变化范围...
linux文件编程,Linux文件编程——系统调用
weixin_32646781的博客
05-04 238
Linux系统调用——文件访问Linux中的文件编程可以使用两种方法：Linux的系统调用C语言库函数前者依赖与Linux系统，后者与操作系统无关。系统调用——创建int creat(const char* filname, mode_t mode)mode:S_IRUSER 可读 -> 1S_IWUSER 可写 -> 2S_IXUSER 可执行 -> 4S_IR...
linux程序设计环境：CH09 Linux程序设计I - 入门、文件操作和环境.pptx
09-17
linux程序设计环境：CH09 Linux程序设计I - 入门、文件操作和环境.pptx
操作系统教程 Linux-菜鸟入门
11-19
操作系统教程“Linux-菜鸟入门”是一份专门为初学者设计的学习资料，涵盖了操作系统的基本概念和Linux系统的核心特性。这个教程通过一系列深入浅出的章节，帮助新手理解操作系统如何管理和协调计算机资源，尤其是...
Linux-C-programming.rar_linux 程序
09-22
3)Linux程序设计入门--文件操作 4)Linux程序设计入门--时间概念 5)Linux程序设计入门--信号处理 6)Linux程序设计入门--消息管理 7)Linux程序设计入门--线程操作 8)Linux程序设计入门--网络编程 9)Linux下C开发...
嵌入式学习笔记_Linux（一）——Linux文件编程
Liang_Quan_Huan的博客
10-24 295
Linux文件编程Linux文件编程有两种方式： 1、Linux系统调用 2、C语言库函数 前者依赖于Linux系统，后者与操作系统是独立的，在任何操作系统下，使用C语言库函数操作文件的方法都是相同的。系统调用：#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int creat(const char *filena
Linux编程学习笔记：文件、时间编程
a568713197的博客
01-30 1622
一、系统调用-文件访问     Linux中文件编程可以使用两种方法         Linux系统调用         C语言库函数     前者依赖LInux系统，后者与操作系统独立，在任何操作系统下库函数操作文件的方法都是相同的     创建         int creat(const char *filename,mode_t mode)         filename...
文件拷贝代码以及疑问
weixin_30727835的博客
03-04 103
Linux下的拷贝代码，没有用ANSI库函数#include <unistd.h> #include <fcntl.h> #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <errno.h> #include <string....
linux c学习笔记----目录文件的操作(opendir,readdir,closedir)
RobertXin
10-26 1797
注：为什么要说目录文件？其实在linux中目录也是一种文件，只是它的内容是上级的目录和当前目录下的文件信息等，详情可以看看相关深入的书籍   opendir（打开目录） 相关函数 open，readdir，closedir，rewinddir，seekdir，telldir，scandir 表头文件 #include&lt;sys/types.h&g...
Linux：基础命令学习
qq_55038440的博客
07-20 1412
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
LINUX之MMC子系统分析
gy794627991的博客
07-23 1065
MMC子系统从协议到源码分析
【Linux】条件变量及生产者消费者模型
2301_78636079的博客
07-23 1088
条件变量与生产消费者模型
linux上导出数据库
最新发布
weixin_43652507的博客
07-24 274
linux上导出数据库 MySQL、PostgreSQL、SQLite、MongoDB
GNU/Linux - Bazaar版本管理工具
guoqx的专栏
07-24 442
根据 Jelmer Vernooij 的说法，Canonical 的 Bazaar 团队的成员在 2012 年初被分配到不同的任务，他本人在7年来为该项目做出贡献后，于2012年底停止了对 Bazaar 的贡献。同样，Bugzilla项目在2014 3月从 Bazaar 改为使用 git，其中一个原因是 Bazaar 几乎已被放弃的印象：“每个月可能有 2-3 次向主干提交。并用来进行Ubuntu项目的版本控制。Bazaar 可以由一个开发本地内容的多个分支的开发人员使用，也可以由跨网络协作的团队使用。
Linux：进程信号（一.认识信号、信号的产生及深层理解、Term与Core）
qq_74415153的博客
07-23 1536
1.认识信号 进程看待信号方式 2.信号的产生 2.1信号的处理的方式 --- signal()函数 2.2kil指令产生信号 2.3键盘产生信号 2.4系统调用发送信号 -kil系统调 用、raise()和abort()库函数 2.5软件条件产生信号 2.6异常产生信号 3.信号产生的深层理解 键盘产生信号 异常产生信号 4.Term与Core core文件
Linux程序设计：深入理解文件操作与系统调用
本篇Linux程序设计入门文章深入探讨了在Linux环境下文件操作的关键概念和技术。首先，作者明确了章节的主要内容，即讲解文件的创建、读写、属性管理和目录文件操作，以及涉及的高级功能——管道文件。 在文件操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值