linux I/O函数集及windows C语言I/O函数集

 

                          linux I/O函数集

----------头文件说明------------------
sys/types.h : 常用变量类型
sys/stat.h  : 文件状态
fcntl.h     : 文件控制
unstd.h     : lseek,read,write...

 -------------文件I/O-----------------
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int oflag...,[  mode_t mode ]);
 第3个参数写为...,这是ANSI C说明余下参数的数目和类型可以变化的方法。  
 O_RDONLY:只读打开,
 O_WRONLY:只写打开,
 O_RDWR : 读、写打开.很多实现将O_RDONLY定 
 O_APPEND:在每次写时都加到文件的尾端。
 O_CREAT :若此文件不存在则创建它。使用此可选项时，需同时说明第三个参数mode
 O_EXCL :如果同时指定了O_CREAT,而文件已经存在,则出错.这使得测试一个文件是否存在,如果不存在则创建此文件成为一个原子操作.
 O_TRUNC :如果此文件存在,而且为只读或只写成功打开,则将其长度截短为0。 
 O_NOCTTY:如果pathname指的是终端设备，则不将此设备分配作为此进程的控制终端.
 O_NONBLOCK:如果pathname指的FIFO、块特殊或字符特殊文件,则此项为文件的打开和后续的I/O操作设置非阻塞方式。
 O_NDELAY(不延迟)标志较早的系统Ⅴ版本引入了，它与O_NONBLOCK(不阻塞)选择项类似， 
 O_SYNC :使每次write都等到物理I/O操作完成。
int create(const char *pathname,mode_t mode);

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

#include <sys/types.h>
#include <unistd.h>
off_t lseek(int filedes, off_t offset, int whence);
  whence的取值为: SEEK_SET SEEK_CUR SEEK_END

#include <unistd.h>
size_t read(int filedes, void *buff, size_t nbytes);
size_t write(int filedes, const void *buff, size_t nbytes);

#include <unistd.h>
int dup(int filedes);
int dup2(int filedes,int filedes2);

#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
int fcntl(int filedes,int cmd,...[int arg]);

#include <unistd.h>
#include <sys/ioctl.h>
int ioctl(int filedes,int request,...);

 -------------标准I/O库---------------
标准I/O库函数都需要#include <stdio.h>

void setbuf(FILE *fp,char *buf);
int setvbuf(FILE *fp,char *buf,int mode,size_t size);

int fflush(FILE *fp);

FILE *fopen(const char *pathname,const char *type);
FILE *freopen(const char *pathname,const char *type,FILE *fp);
FILE *fdopen(int filedes,const char *type);

int ferror(FILE *fp);
int feof(FILE *fp);

int getc(FILE *fp);
int fgetc(FILE *fp);
int getchar(void);
int ungetc(int c , FILE *fp);
int putc(int c, FILE *fp);
int fputc(int c, FILE *fp);
int putchar(int c);

char *fgets(char *buf, int n, FILE *fp);
char *gets(char *buf);
int fputs(const char *str,FILE *fp);
int puts(const char *str);

size_t fread(void *ptr,size_t size, size_t nobj,FILE *fp);
size_t fwrite(const void *ptr,size_t size, size_t nobj,FILE *fp);

logn ftell(FILE *fp);
int fseek(FILE *fp, long offset, int whence);
void rewind(FILE *fp);
int fgetpos(FILE *fp, fpos_t *pos);
int fsetpos(FILE *fp, const fpost_t *pos);

int printf(cosnt char *format,...);
int fprintf(FILE *fp, const char *format,...);
int sprintf(char *buf,const char *format,...);
int scanf(const char *format,...);
int fscanf(FILE *fp, const char *format,...);
int sscanf(const char *buf,const char *format,...);
#include <stdarg.h>
int vprintf(const char *format,va_list arg);
int vfprintf(FILE *fp,const char *foramt,va_list arg);
int vspritnf(char *buf,const char *format,va_list arg);

int fileno(FILE *fp);

char *tmpname(char *ptr);
FILE *tmpfile(void);
char *tmpname(const char *directory, const char *prefix);

 -------------文件和目录--------------
获取文件属性
#include <sys/types.h>
#include <sys/stat.h>
int stat(const char *file_name,struct stat *buf);
int fstat(int filedes,struct stat *buf);
  struct stat {
   dev_t st_dev;    // 设备
   ino_t st_ino;    // 节点
   mode_t st_mode;    // 模式
   nlink_t st_nlink;   // 硬连接
   uid_t st_uid;    // 用户ID
   gid_t st_gid;    // 组ID
   dev_t st_rdev;    // 设备类型
   off_t st_off;    // 文件字节数
   unsigned long st_blksize; // 块大小
   unsigned long st_blocks; // 块数
   time_t st_atime;   // 最后一次访问时间
   time_t st_mtime;   // 最后一次修改时间
   time_t st_ctime;   // 最后一次改变时间(指属性)
  };
  S_ISLNK(st_mode):是否是一个连接.
  S_ISREG是否是一个常规文件.
  S_ISDIR是否是一个目录
  S_ISCHR是否是一个字符设备
  S_ISBLK是否是一个块设备
  S_ISFIFO是否 是一个FIFO文件.
  S_ISSOCK是否是一个SOCKET文件.

判断是否具有存取文件的权限
#include <unistd.h>
int access(const char *pathname, int mode); //R_OK,W_OK,X_OK,F_OK
 

改变文件的权限
#include <sys/types.h>
#include <sys/stat.h>
mode_t umask(mode_t cmask);
int chmod(const char *pathname,mode_t mode);
int fchmod(int filedes,mode_t mode);
 参数  mode 有下列数种组合
 S_ISUID 04000 文件的（set user-id on execution）位
 S_ISGID 02000 文件的（set group-id on execution）位
 S_ISVTX 01000 文件的sticky位
 S_IRUSR（S_IREAD） 00400 文件所有者具可读取权限
 S_IWUSR（S_IWRITE）00200 文件所有者具可写入权限
 S_IXUSR（S_IEXEC） 00100 文件所有者具可执行权限
 S_IRGRP 00040 用户组具可读取权限
 S_IWGRP 00020 用户组具可写入权限
 S_IXGRP 00010 用户组具可执行权限
 S_IROTH 00004 其他用户具可读取权限
 S_IWOTH 00002 其他用户具可写入权限
 S_IXOTH 00001 其他用户具可执行权限
 只有该文件的所有者或有效用户识别码为0，才可以修改该文件权限。

改变文件的所有者
#include <sys/types.h>
#include <unistd.h>
int chown(const char *pathname,uid_t owner, gid_t group);
int fchown(int filedes,uid_t owner,gid_t group);

文件截短
#include <sys/types.h>
#include <unistd.h>
int truncate(const char *pathname, off_t length);
int ftruncate(int filedes,off_t length);

硬连接
#include <unistd.h>
int link(const char *existingpath, const char *newpath);
int unlink(const char * pathname);

符号连接
#include <unistd.h>
int symlink(const char *actualpath, const char * sympath);
int readlink(const char *pathname,char *buf,int bufsize);

删除文件或目录
#include <stdio.h>
int remove(const char *pathname);

为文件或目录更名
#include <stdio.h>
int rename(const char *oldname,const char * newname);

存取和修改时间
#include <sys/types.h>
#include <utime.h>
int utime(const char *pathname,const struct utimbuf *times);
 struct utimbuf{
  time_t actime;  //access time
  time_t modtime; //modefication time
 }

创建删除目录
#include <sys/types.h>
#include <sys/stat.h>
int mkdir(const char *pathname, mode_t mode);
#include <unistd.h>
int rmdir(const char *pathname);

读目录
#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *pathname);
struct dirent *readdir(DIR *dp);
void rewinddir(DIR *dp);
int closedir(DIR *dp);
 struct dirent
 {
  ino_t d_ino;
  ff_t d_off;
  signed short int d_reclen;
  unsigned char d_type;
  har d_name[256];
 };

当前目录与更改
#include <unistd.h>
int chdir(const char *pathname);
int fchdir(int filedes); //文件目录的的描述符.
char *getcwd(char *buf, size_t size);

内核文件缓存刷新
#include <unistd.h>
void sync(void); //只是将所有修改过的块的缓存排入写队列,并不等待实际I/O操作.
int fsync(int filedes);//等待到该文件写入设备

 -------------高级I/O-----------------
设置非阻塞i/o
  open时设定O_NONBLOCK, 或fcntl设定O_NONBLOCK

记录锁
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
int fcntl(int filedes,int cmd,struct flock *flockptr);
 cmd取值: F_GETLK F_SETLK F_SETLKW
 struct flok{
  short l_type;  //F_RDLCK F_WRLCK F_UNLCK
  off_t l_start;  //offset in bytes, relative to l_whence
  short l_whence; //SEEK_SET, SEEK_CUR ,SEEK_END
  off_t l_len;  //length ,in bytes , 0 means lock to EOF
  pid_t l_pid;  //return with F_GETLK
 };

I/O多路转接
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
int select(int maxfdpl, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *tvptr);
 struct timeval{
  long tv_sec;
  long tv_usec;
 };

散布读, 聚集写
#include <sys/types.h>
#include <sys/uio.h>
size_t readv(int filedes,const struct iovec[],int iovcnt);
size_t writev(int filedes,const struct iovec[],int iovcnt);
 struct iovec{
  void *iov_base;
  size_t iov_len;
 };

存储映射I/O
#include <sys/types.h>
#include <sys/mman.h>
caddr_t mmap(caddr_t addr, size_t len, int prot,int flag,int filedes,off_t off);
   prot取值: PROT_READ PROT_WRITE PROT_EXEC PROT_NONE
   flag取值: MAP_FIXED MAP_SHARED MAP_PRIVATE
int munmap(caddr_t addr, size_t len);

windows C语言I/O函数集

 -------------文件I/O-----------------
int   open(char *pathname,int access,...[,int permiss])
  access值见下表
        ┌────┬────────────────────┐
        │access值│意义                                    │
        ├────┼────────────────────┤
        │O_RDONLY│读文件                                  │
        │O_WRONLY│写文件                                  │
        │O_RDWR  │即读也写                                │
        │O_NDELAY│没有使用;对UNIX系统兼容                 │
        │O_APPEND│即读也写,但每次写总是在文件尾添加       │
        │O_CREAT │若文件存在,此标志无用;若不存在,建新文件 │
        │O_TRUNC │若文件存在,则长度被截为0,属性不变       │
        │O_EXCL  │未用;对UNIX系统兼容                     │
        │O_BINARY│此标志可显示地给出以二进制方式打开文件  │
        │O_TEXT  │此标志可用于显示地给出以文本方式打开文件│
        └────┴────────────────────┘
        仅当创建新文件时才使用第三个参数,permiss为文件属性,可为以下值:
         S_IWRITE允许写  S_IREAD允许读  S_IREAD|S_IWRITE允许读、写
int   creat(char *filename,int permiss) 
  permiss为文件读写性，可以为以下值
        S_IWRITE允许写  S_IREAD允许读  S_IREAD|S_IWRITE允许读、写
int   creatnew(char *filenamt,int attrib)
  attrib为文件属性，可以为以下值
         FA_RDONLY只读  FA_HIDDEN隐藏  FA_SYSTEM系统
int   creattemp(char *filenamt,int attrib)
  attrib为文件属性，可以为以下值
         FA_RDONLY只读  FA_HIDDEN隐藏  FA_SYSTEM系统
int   read(int handle,void *buf,int nbyte)
int   write(int handle,void *buf,int nbyte)
int   dup(int handle)
int   dup2(int handle,int newhandle)
int   eof(int *handle)
long  filelength(int handle)
int   setmode(int handle,unsigned mode)
  本函数用来设定文件号为handle的文件的打开方式
int   getftime(int handle,struct ftime *ftime)
  读取文件号为handle的文件的时间，
        并将文件时间存于ftime结构中，成功返回0,ftime结构如下：
        ┌─────────────────┐
        │struct ftime                      │
        │{                                 │
        │ unsigned ft_tsec:5;   //秒       │
        │ unsigned ft_min:6;    //分       │
        │ unsigned ft_hour:5;   //时       │
        │ unsigned ft_day:5;    //日       │
        │ unsigned ft_month:4;  //月       │
        │ unsigned ft_year:1;   //年-1980  │
        │}                                 │
        └─────────────────┘
int   setftime(int handle,struct ftime *ftime)
  重写文件号为handle的文件时间,
  新时间在结构ftime中.成功返回0.结构ftime如下:
        ┌─────────────────┐
        │struct ftime                      │
        │{                                 │
        │ unsigned ft_tsec:5;   //秒       │
        │ unsigned ft_min:6;    //分       │
        │ unsigned ft_hour:5;   //时       │
        │ unsigned ft_day:5;    //日       │
        │ unsigned ft_month:4;  //月       │
        │ unsigned ft_year:1;   //年-1980  │
        │}                                 │
        └─────────────────┘
long  lseek(int handle,long offset,int fromwhere)
         SEEK_SET 文件开关   SEEK_CUR 当前位置   SEEK_END 文件尾
long  tell(int handle)
int   isatty(int handle)
int   lock(int handle,long offset,long length)   对文件共享作封锁
int   unlock(int handle,long offset,long length) 打开对文件共享的封锁
int   close(int handle)

   -------------标准I/O库---------------
#include<stdio.h>
FILE *fopen(char *filename,char *type) 打
  type可为以下字符串加上后缀
      ┌──┬────┬───────┬────────┐
      │type│读写性  │文本/2进制文件│建新/打开旧文件 │
      ├──┼────┼───────┼────────┤
      │r   │读      │文本          │打开旧的文件    │
      │w   │写      │文本          │建新文件        │
      │a   │添加    │文本          │有就打开无则建新│
      │r+  │读/写   │不限制        │打开            │
      │w+  │读/写   │不限制        │建新文件        │
      │a+  │读/添加 │不限制        │有就打开无则建新│
      └──┴────┴───────┴────────┘
      可加的后缀为t、b。加b表示文件以二进制形式进行操作，t没必要使用
FILE *fdopen(int ahndle,char *type)
FILE *freopen(char *filename,char *type,FILE *stream)
int   getc(FILE *stream) 
int   putc(int ch,FILE *stream)
int   getw(FILE *stream)
int   putw(int w,FILE *stream)
int   ungetc(char c,FILE *stream)
int   fgetc(FILE *stream)
int   fputc(int ch,FILE *stream)
char *fgets(char *string,int n,FILE *stream)
int   fputs(char *string,FILE *stream)
int   fread(void *ptr,int size,int nitems,FILE *stream) (二进制I/O)
int   fwrite(void *ptr,int size,int nitems,FILE *stream) (二进制I/O)
int   fscanf(FILE *stream,char *format[,argument,…])
int   vfscanf(FILE *stream,char *format,Valist param)
int   fprintf(FILE *stream,char *format[,argument,…]) 
int   vfprintf(FILE *stream,char *format,Valist param) 
int   fseek(FILE *stream,long offset,int fromwhere)
  fromwhere可以为以下值:
        SEEK_SET 文件开关   SEEK_CUR 当前位置   SEEK_END 文件尾
long  ftell(FILE *stream) 
  函数返回定位在stream中的当前文件指针位置,以字节表示
int   rewind(FILE *stream)
  将当前文件指针stream移到文件开头
int   feof(FILE *stream)
int   fileno(FILE *stream)
  取流stream上的文件处理，并返回文件处理
int   ferror(FILE *stream)
void  clearerr(FILE *stream)
void  setbuf(FILE *stream,char *buf)
  给流stream指定一个缓冲区buf
void  setvbuf(FILE *stream,char *buf,int type,unsigned size)
       给流stream指定一个缓冲区buf,大小为size,类型为type,type的值见下表
    涉及终端设备是行缓存,否则是全缓存.
      ┌───┬───────────────────────────────┐
      │type值│意义                                                          │
      ├───┼───────────────────────────────┤
      │_IOFBF│文件是完全缓冲区,当缓冲区是空时,下一个输入操作将企图填满整个缓│
      │      │冲区.在输出时,在把任何数据写到文件之前,将完全填充缓冲区.      │
      │_IOLBF│文件是行缓冲区.当缓冲区为空时,下一个输入操作将仍然企图填整个缓│
      │      │冲区.然而在输出时,每当新行符写到文件,缓冲区就被清洗掉.        │
      │_IONBF│文件是无缓冲的.buf和size参数是被忽略的.每个输入操作将直接从文 │
      │      │件读,每个输出操作将立即把数据写到文件中.                      │
      └───┴───────────────────────────────┘
int   fclose(FILE *stream) 关闭一个流，可以是文件或设备(例如LPT1)
int   fcloseall()          关闭所有除stdin或stdout外的流
int   fflush(FILE *stream)
int   fflushall()   

 -------------文件和目录--------------

int   access(char *filename,int amode) 本函数检查文件filename并返回文件的属性,
        函数将属性存于amode中，amode由以下位的组合构成
          06可以读、写       04可以读   02可以写   01执行(忽略的)   00文件存在
      如果filename是一个目录,函数将只确定目录是否存在
      函数执行成功返回0,否则返回-1
int   chmod(char *filename,int permiss) 本函数用于设定文件filename的属性
        permiss可以为以下值
           S_IWRITE允许写  S_IREAD允许读  S_IREAD|S_IWRITE允许读、写
char *_fullpath( char *absPath, const char *relPath, size_t maxLength );
char *_mktemp(  char *template );
int remove( const char *path );
int rename( const char *oldname,const char *newname );
void _makepath(char *path,const char *drive,const char *dir,const char *fname,const char *ext );
void _splitpath(const char *path,char *drive,char *dir,char *fname,char *ext);
int _stat(const char *path,struct _stat *buffer);
int _umask( int pmode );
int _unlink( const char *filename );

目录函数,所在函数库为dir.h、dos.h
int chdir(char *path) 使指定的目录path（如:"C:\\WPS"）变成当前的工作目录,成功返回0
int findfirst(char *pathname,struct ffblk *ffblk,int attrib)查找指定的文件,成功返回0
     pathname为指定的目录名和文件名,如"C:\\WPS\\TXT"
     ffblk为指定的保存文件信息的一个结构,定义如下:
    ┏━━━━━━━━━━━━━━━━━━┓
    ┃struct ffblk                        ┃
    ┃{                                   ┃
    ┃ char ff_reserved[21]; //DOS保留字  ┃
    ┃ char ff_attrib;       //文件属性   ┃
    ┃ int  ff_ftime;        //文件时间   ┃
    ┃ int  ff_fdate;        //文件日期   ┃
    ┃ long ff_fsize;        //文件长度   ┃
    ┃ char ff_name[13];     //文件名     ┃
    ┃}                                   ┃
    ┗━━━━━━━━━━━━━━━━━━┛
     attrib为文件属性,由以下字符代表
    ┏━━━━━━━━━┳━━━━━━━━┓
    ┃FA_RDONLY 只读文件┃FA_LABEL  卷标号┃
    ┃FA_HIDDEN 隐藏文件┃FA_DIREC  目录  ┃
    ┃FA_SYSTEM 系统文件┃FA_ARCH   档案  ┃
    ┗━━━━━━━━━┻━━━━━━━━┛
    例:
    struct ffblk ff;
    findfirst("*.wps",&ff,FA_RDONLY);
int   findnext(struct ffblk *ffblk)      取匹配finddirst的文件,成功返回0
void  fumerge(char *path,char *drive,char *dir,char *name,char *ext)
       此函数通过盘符drive(C:、A:等),路径dir(\TC、\BC\LIB等),
       文件名name(TC、WPS等),扩展名ext(.EXE、.COM等)组成一个文件名
       存与path中.
int   fnsplit(char *path,char *drive,char *dir,char *name,char *ext)
       此函数将文件名path分解成盘符drive(C:、A:等),路径dir(\TC、\BC\LIB等),
       文件名name(TC、WPS等),扩展名ext(.EXE、.COM等),并分别存入相应的变量中.
int   getcurdir(int drive,char *direc) 此函数返回指定驱动器的当前工作目录名称
        drive 指定的驱动器(0=当前,1=A,2=B,3=C等)
        direc 保存指定驱动器当前工作路径的变量      成功返回0
char *getcwd(char *buf,iint n) 此函数取当前工作目录并存入buf中,直到n个字节长为为止.错误返回NULL
int   getdisk() 取当前正在使用的驱动器,返回一个整数(0=A,1=B,2=C等)
int   setdisk(int drive) 设置要使用的驱动器drive(0=A,1=B,2=C等),返回可使用驱动器总数
int   mkdir(char *pathname)  建立一个新的目录pathname,成功返回0
int   rmdir(char *pathname)  删除一个目录pathname,成功返回0
char *mktemp(char *template) 构造一个当前目录上没有的文件名并存于template中
char *searchpath(char *pathname) 利用MSDOS找出文件filename所在路径,此函数使用DOS的PATH变量,未找到文件返回NULL