系统级IO

打开和关闭文件

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
//flags参数指明了进程打算如何访问这个文件：O_RDONLY,O_WRONLY,O_RDWR,O_CREAT,O_TRUNC,O_APPEND
//mode表示读写访问权限，一般和umask（）函数配合使用，文件访问权限为：mode&~umask
int open(char *filename,int flags,mode_t mode);

#include <unistd.h>
int close(int fd);

读和写文件

#include <unistd.h>
#include <sys/types.h>
//从描述符为fd的当前文件位置复制最多n个字节到内存buf中。返回值-1表示一个错误，返回值0表示EOF，读到文件末尾。否则返回值表示实际传送字节的数量
ssize_t read(int fd,void *buf,size_t n);

ssize_t write(int fd,const void *buf,size_t n);

使用RIO包健壮的读写

无缓冲区的输入输出函数（直接在内存和文件之间传送数据，可用于从网络中读取二进制文件或者写入到网络）

//读
#include <sys/type.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
ssize_t rio_readn(int fd,void *userbuf,size_t n);
ssize_t rio_readn(int fd,void *userbuf,size_t n){
    ssize_t nleft = n;
    ssize_t nread ;
    char *bufp = userbuf;
    while(nleft>0){
        if((nread = read(fd,bufp,nleft))<0){
            if(errno==EINTR){
                nread = 0;
            }
            else
                return -1;
        }
        else if(nread==0){
            break;
        }
        nleft-=nread;
        bufp+=nread;
    }
    return (n-nleft);
}

//写
#include <sys/type.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
ssize_t rio_writen(int fd, void *userbuf,size_t n);
ssize_t rio_writen(int fd, void *userbuf,size_t n){
    ssize_t nleft = n;
    ssize_t nwrite;
    char *bufp = userbuf;
    while(nleft>0){
        if((nwrite = write(fd,bufp,nleft))<0){
            if(errno==EINTR){
                nwrite = 0;
            }
            else
                return -1;
        }
        else if(nwrite==0){
            break;
        }
        nleft-=nwrite;
        bufp+=nwrite;
    }
    return (n-nleft);
}

带缓冲区的输入函数（线程安全[可对缓冲区加锁]）

#include <sys/type.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>
#define RIO_BUFSIZE 8192
typedef struct{
    int rio_fd;
    int rio_cnt;
    char *rio_bufptr;
    char rio_buf[RIO_BUFSIZE];
}rio_t;
ssize_t rio_read(rio_t *rp,char *userbuf,size_t n);
void rio_readinitb(rio_t *rp,int fd);
ssize_t rio_readlineb(rio_t *rp,void *userbuf,size_t maxlen);

ssize_t rio_read(rio_t *rp,char *userbuf,size_t n){
    int cnt;
    while(rp->rio_cnt<=0){
        rp->rio_cnt = read(rp->fd,rp->buf,sizeof(rp->rio_buf));
        if(rp->rio_cnt<0){
            if(errno!=EINTR)
                return -1;
        }
        else if(rp->rio_cnt==0){
            return 0;
        }
        else
            rp->rio_bufptr = rp->rio_buf;
    }
    cnt = n;
    if(rp->rio_cnt<n)
        cnt = rp->rio_cnt;
    memcpy(userbuf,rp->rio_bufptr,cnt);
    rp->rio_bufptr+=cnt;
    rp->rio_cnt-=cnt;
    return cnt;
}

//init
void rio_readinitb(rio_t *rp,int fd){
    rp->rio_cnt = 0;
    rp->fd = fd;
    rp->rio_bufptr = rp->rio_buf;
}

//读一行,一个一个字的读
ssize_t readlineb(rio_t *rp,void *userbuf,size_t maxlen){
    int n,rc;
    char c,*buf = userbuf;
    for(n = 1; n < maxlen; n++){
        if(rc = rio_read(rp,&c,1)==1){
            *buf++ = c;
            if(c=='\n'){
                n++;
                break;
            }
        }else if(rc==0){
            if(n==1)
                return 0;
            else 
                break;
        }
        else
            return -1;
    }
    *buf = 0;
    return n-1;
}