文件操作(linux下c)

文件的创建和读写
当我们需要打开一个文件进行读写操作的时候,我们可以使用系统调用函数open.使用完
成以后我们调用另外一个close 函数进行关闭操作.
#include ;
#include ;
#include ;
#include ;
int open(const char *pathname,int flags);
int open(const char *pathname,int flags,mode_t mode);
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 ;
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 中,成功时返回实际所写的字节数.
一个实例
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#define BUFFER_SIZE 1024
int main(int argc,char **argv)
{
int from_fd,to_fd;
int bytes_read,bytes_write;
char buffer[BUFFER_SIZE];
char *ptr;
if(argc!=3)
{
fprintf(stderr,"Usage：%s fromfile tofile\n\a",argv[0]);
exit(1);
}
/* 打开源文件 */
if((from_fd=open(argv[1],O_RDONLY))==-1)
{
fprintf(stderr,"Open %s Error：%s\n",argv[1],strerror(errno));
exit(1);
}
/* 创建目的文件 */
if((to_fd=open(argv[2],O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))==-1)
{
fprintf(stderr,"Open %s Error：%s\n",argv[2],strerror(errno));
exit(1);
}
/* 以下代码是一个经典的拷贝文件的代码 */
while(bytes_read=read(from_fd,buffer,BUFFER_SIZE))
{
/* 一个致命的错误发生了 */
if((bytes_read==-1)&&(errno!=EINTR)) break;
else if(bytes_read>;0)
{
ptr=buffer;
while(bytes_write=write(to_fd,ptr,bytes_read))
{
/* 一个致命错误发生了 */
if((bytes_write==-1)&&(errno!=EINTR))break;
/* 写完了所有读的字节 */
else if(bytes_write==bytes_read) break;
/* 只写了一部分,继续写 */
else if(bytes_write>;0)
{
ptr+=bytes_write;
bytes_read-=bytes_write;
}
}
/* 写的时候发生的致命错误 */
if(bytes_write==-1)break;
}
}
close(from_fd);
close(to_fd);
exit(0);
}





文件的各个属性


文件出了具有文件权限的属性以外,文件还有创建时间,大小等等属性.
有时侯我们要判断文件是否可以进行某种操作(读,写等等).这个时候我们可以使用access
函数.
#include ;
int access(const char *pathname,int mode);
pathname：是文件名称,mode 是我们要判断的属性.可以取以下值或者是他们的组合.
R_OK 文件可以读,W_OK 文件可以写,X_OK 文件可以执行,F_OK 文件存在.当我们测试成功
时,函数返回0,否则如果有一个条件不符时,返回-1.
如果我们要获得文件的其他属性,我们可以使用函数stat 或者fstat.
#include ;
#include ;
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; /* 最后一次改变时间(指属性) */
};
stat 用来判断没有打开的文件,而fstat 用来判断打开的文件.我们使用最多的属性是st_
mode.通过着属性我们可以判断给定的文件是一个普通文件还是一个目录,连接等等.可以
使用下面几个宏来判断.
S_ISLNK(st_mode)：是否是一个连接.
S_ISREG 是否是一个常规文件.
S_ISDIR 是否是一个目录
S_ISCHR 是否是一个字符设备.
S_ISBLK 是否是一个块设备
S_ISFIFO 是否 是一个FIFO文件.
S_ISSOCK 是否是一个SOCKET 文件.




目录文件的操作
在我们编写程序的时候，有时候会要得到我们当前的工作路径。C 库函数提供了getcwd 来解决这个问题。
#include ;
char *getcwd(char *buffer,size_t size);
我们提供一个size 大小的buffer,getcwd 会把我们当前的路径考到buffer 中.如果buffer
太小,函数会返回-1 和一个错误号.
Linux 提供了大量的目录操作函数,下面是几个比较简单和常用的函数.
#include ;
#include ;
#include ;
#include ;
#include ;
int mkdir(const char *path,mode_t mode);
DIR *opendir(const char *path);
struct dirent *readdir(DIR *dir);
void rewinddir(DIR *dir);
off_t telldir(DIR *dir);
void seekdir(DIR *dir,off_t off);
int closedir(DIR *dir);
struct dirent {
long d_ino;
off_t d_off;
unsigned short d_reclen;
char d_name[NAME_MAX+1]; /* 文件名称 */
下面有一个小程序,这个程序有一个参数.如果这个参数是一个文件名,我们输出这
个文件的大小和最后修改的时间,如果是一个目录我们输出这个目录下所有文件的大小和
修改时间.
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
static int get_file_size_time(const char *filename)
{
struct stat statbuf;
if(stat(filename,&statbuf)==-1)
{
printf("Get stat on %s Error：%s\n",
filename,strerror(errno));
return(-1);
}
if(S_ISDIR(statbuf.st_mode))return(1);
if(S_ISREG(statbuf.st_mode))
printf("%s size：%ld bytes\tmodified at %s",
filename,statbuf.st_size,ctime(&statbuf.st_mtime));
return(0);
}
int main(int argc,char **argv)
{
DIR *dirp;
struct dirent *direntp;
int stats;
if(argc!=2)
{
printf("Usage：%s filename\n\a",argv[0]);
exit(1);
}
if(((stats=get_file_size_time(argv[1]))==0)||(stats==-1))exit(1);
if((dirp=opendir(argv[1]))==NULL)
{
printf("Open Directory %s Error：%s\n",
argv[1],strerror(errno));
exit(1);
}
while((direntp=readdir(dirp))!=NULL)
if(get_file_size_time(direntp-closedir(dirp);
exit(1);
}


管道文件

Linux 提供了许多的过滤和重定向程序,比如more cat
等等.还提供了< > | <<等等重定向操作符.在这些过滤和重 定向程序当中,都用到了
管道这种特殊的文件.系统调用pipe 可以创建一个管道.
#include;
int pipe(int fildes[2]);
pipe 调用可以创建一个管道(通信缓冲区).当调用成功时,我们可以访问文件描述符fild
es[0],fildes[1].其中fildes[0]是用来读的文件描述符,而fildes[1]是用来写的文件描
述符.
在实际使用中我们是通过创建一个子进程,然后一个进程写,一个进程读来使用的.
关于进程通信的详细情况请查看进程通信
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#define BUFFER 255
int main(int argc,char **argv)
{
char buffer[BUFFER+1];
int fd[2];
if(argc!=2)
{
fprintf(stderr,"Usage：%s string\n\a",argv[0]);
exit(1);
}
if(pipe(fd)!=0)
{
fprintf(stderr,"Pipe Error：%s\n\a",strerror(errno));
exit(1);
}
if(fork()==0)
{
close(fd[0]);
printf("Child[%d] Write to pipe\n\a",getpid());
snprintf(buffer,BUFFER,"%s",argv[1]);
write(fd[1],buffer,strlen(buffer));
printf("Child[%d] Quit\n\a",getpid());
exit(0);
}
else
{
close(fd[1]);
printf("Parent[%d] Read from pipe\n\a",getpid());
memset(buffer,'\0',BUFFER+1);
read(fd[0],buffer,BUFFER);
printf("Parent[%d] Read：%s\n",getpid(),buffer);
exit(1);
}
}

为了实现重定向操作,我们需要调用另外一个函数dup2.
#include ;
int dup2(int oldfd,int newfd);
dup2 将用oldfd 文件描述符来代替newfd 文件描述符,同时关闭newfd 文件描述符.也就是说
,
所有向newfd 操作都转到oldfd 上面.下面有一个示例，将标准输出重定向
到一个文件.
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#include ;
#define BUFFER_SIZE 1024
int main(int argc,char **argv)
{
int fd;
char buffer[BUFFER_SIZE];
if(argc!=2)
{
fprintf(stderr,"Usage：%s outfilename\n\a",argv[0]);
exit(1);
}
if((fd=open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1)
{
fprintf(stderr,"Open %s Error：%s\n\a",argv[1],strerror(errno));
exit(1);
}
if(dup2(fd,STDOUT_FILENO)==-1)
{
fprintf(stderr,"Redirect Standard Out Error：%s\n\a",strerror(errno));
exit(1);
}
fprintf(stderr,"Now,please input string");
fprintf(stderr,"(To quit use CTRL+D)\n");
while(1)
{
fgets(buffer,BUFFER_SIZE,stdin);
if(feof(stdin))break;
write(STDOUT_FILENO,buffer,strlen(buffer));
}
exit(0);
}