Linux下文件操作 系统调用与标准I/O库

系统调用与标准I/O库

一、系统调用概述

UNIX系统的软件层次

1.系统调用是操作系统提供给用户程序的一组“特殊”接口。

2.Linux的不同版本提供了两三百个系统调用。

3.用户程序可以通过这组接口获得操作系统（内核）提供的服务。

例如：

用户可以通过文件系统相关的系统调用，请求系统打开文件、关闭文件或读写文件。

4.系统调用按照功能逻辑大致可分为:

       进程控制、进程间通信、文件系统控制、系统控制、内存管理、网络管理、       socket控制、用户管理。如下图：

5.系统调用通常通过函数进行调用。

 系统调用的返回值：

       通常，用一个负的返回值来表明错误，返回一个0值表明成功。错误信息存       放在全局变量errno中，用户可用perror函数打印出错信息。

6.在Linux中，应用程序编程接口(API)遵循POSIX标准。

       POSIX标准描述了操作系统的函数接口规范（函数名、返回值、参数等）。不       同操作系统下编写的程序只要遵循POSIX标准，程序都可以直接移植。

       如：

              linux下写的open、write 、read可以直接移植到unix操作系统下。

二、系统调用I/O函数

1.系统调用中操作I/O的函数，都是针对文件描述符的。通过文件描述符可以直接对相应的文件进行操作。

       如：open、close、write 、read、ioctl

2. 文件描述符

       文件描述符是非负整数。打开现存文件或新建文件时，系统（内核）会返回一个文件描述符。文件描述符用来指定已打开的文件。

3. 程序运行起来后这三个文件描述符是默认打开的。

       #defineSTDIN_FILENO 0   //标准输入的文件描述符

       #defineSTDOUT_FILENO 1 //标准输出的文件描述符

       #defineSTDERR_FILENO 2        //标准错误的文件描述符

4. open函数：打开一个文件

   #include <sys/types.h>   定义新的数据类型

   #include <sys/stat.h>       文件信息结构体的定义

   #include <fcntl.h>          声明系统调用

   int open(const char *pathname, int flags);

   int open(const char *pathname,int flags,mode_t mode);

       参数：

              pathname：文件的路径及文件名。

              flags：open函数的行为标志。

              mode：文件权限(可读、可写、可执行)的设置。

       返回值：

              成功返回打开的文件描述符。

              失败返回-1，可以利用perror去查看原因

       例：open(“/home/…/text”,O_RDONLY);

              char *p=” /home/…/text”;

              open(p,O_RDONLY);

5. close函数：关闭一个文件

   #include <unistd.h>

   int close(int fd);

       参数：

              fd是调用open打开文件返回的文件描述符

       返回值：

              成功返回0。

              失败返回-1，可以利用perror去查看原因

6. write函数：把指定数目的数据写到文件

       #include <unistd.h>

   ssize_t write(int fd, const void *addr,size_t count);

       参数：

              fd：文件描述符。

              addr：数据首地址。

              count：写入数据的字节个数。

       返回值：

              成功返回实际写入数据的字节个数。

              失败返回-1，可以利用perror去查看原因。

7. read函数：把指定数目的数据读到内存

   #include <unistd.h>

   ssize_t read(int fd, void *addr, size_t count);

       参数：

              fd：文件描述符。

              addr：内存首地址。

              count：读取的字节个数。

       返回值：

              成功返回实际读取到的字节个数。

              失败返回-1，可以利用perror去查看原因。

例子：read wirte 读取写入数据

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

int main()
{
    int fd;
    char* path = "/home/liang/MyLearn/file/text";
    char buff1[40],buff2[] = "-end:";
    printf("程序开始n");

    //以可读可写方式打开文件，并赋予文件所有者rwx权限
    if ( (fd = open(path,O_RDWR|O_CREAT,0700)) < 0){
        perror("打开失败n");
        return -1;
    }
    printf("打开文件：%sn",path);

    printf("请输入要写入文件的字符：");
    scanf("%s",buff1);
    //strlen(buff1) buff1所含的字符数
    if( write(fd,buff1,strlen(buff1)) < 0 ){
        perror("写入文件失败");
        return -1;
    }
    printf("写入成功n");

    buff1[0]='';//将buff1清空
    lseek(fd,0,SEEK_SET);//定位到文件开头
    if( read(fd,buff1,BUFSIZ) < 0 ){
        perror("读取失败n");
        return -1;
    }
    printf("读取数据：%sn",buff1);

    //关闭文件
    if(close(fd)<0){
        perror("关闭失败");
        return -1;
    }
    printf("关闭文件%sn",path);
    printf("程序结束n");
    return 0;
}

三、系统调用与内核

1.为了更好地保护了内核，在Linux中，把程序运行空间分为内核空间和用户空间，它们分别运行在不同的级别上。

2.用户进程在通常情况下不允许访问内核数据，也无法使用内核函数。

3.但在有些情况下，用户空间的进程需要获得一定的系统服务，这时，就必须通过系统调用。

4. 应用程序运行在用户空间，系统调用需要切换到内核空间，应用程序应该以某种方式通知内核需要切换到内核空间

5. 通知内核的机制是靠软件中断实现的:

       应用程序执行异常指令，引发一个异常，程序进入中断，系统切换到内核态       去执行异常处理程序（系统调用处理程序syscall()）。

6. 所有的系统调用陷入内核的方式都一样，所以仅仅是陷入内核空间是不够的。       还必须以某种方式通知内核进入异常的原因。

7. Unix系统通过系统调用号通知内核进入异常的原因。

8. 系统调用号

       操作系统给每个系统调用分配了一个唯一的编号（系统调用号）。

       用户空间进程执行一个系统调用时，这个系统调用号就被用来指明执行哪个       系统调用。

       系统调用号相当关键，一旦分配就不能再有任何变更，否则编译好的应用程       序会崩溃。此外，如果一个系统调用被删除，它所占用的系统调用号也不允许被

回收利用。

9. 路径：/usr/include/i386-linux-gnu/asm/unistd_32.h

四、系统调用与库

1.     库函数由两类函数组成

1）不需要调用系统调用

        不需要切换到内核空间即可完成函数全部功能，并且将结果反馈给应用程序，如strcpy、bzero等字符串操作函数。

2）需要调用系统调用

需要切换到内核空间，这类函数通过封装系统调用去实现相应功能，如printf、fread等。

2.     库函数与系统调用的关系：

并不是所有的系统调用都被封装成了库函数，系统提供的很多功能都必须通过系统调用才能实现。

3.     系统调用是需要时间的，程序中频繁的使用系统调用会降低程序的运行效率。1）1）当运行内核代码时，CPU工作在内核态，在系统调用发生前需要保存用户态的栈和内存环境，然后转入系统态工作

2）系统调用结束后，又要切换回用户态。这种环境的切换会消耗掉许多时间。

4.     库函数访问文件的时根据需要设置不同类型的缓冲区，从而减少了直接调用IO系统调用的次数，提高了访问效率。

例：应用程序调用printf函数时，函数执行的过程

五、标准I/O库函数

1.     无论是编写系统程序还是应用程序，都离不开I/O这个重要的环节

2.     相对于低级的I/O操作(即系统调用级的I/O)，标准I/O库函数处理了很多细节，如缓存分配等。

3.     考虑到代码的可移植性，开发人员应该在编写代码时尽可能使用标准库函数。

4.     I/O的管理分类

1）由ANSI标准提供的标准IO库函数

几乎被所有的操作系统支持，如winsdows下编写的程序几乎不用做任何修改就可以在linux下重新编译运行。

如：fopen、fread、fwrite、fclose。

2）以系统调用的方式给用户提供函数接口(遵循POSIX标准)

例如linux操作系统提供的文件IO接口。

如：open、close、read、write、ioctl。

系统调用与操作系统直接相关，直接使用系统调用编写的程序可移植性差。

5.     头文件<stdio.h>中声明了标准C的I/O库，标准C的I/O库在所有通用计算机上的C语言实现都是相同的。

6.     对于标准I/O操作函数来说，打开或创建一个文件的时候，会返回一个指向FILE结构体的指针。

7.     FILE结构体包含了I/O函数库为管理文件所需要的尽可能多的信息。包括了用于I/O文件的文件描述符、指向流缓存的指针、缓存长度等。

8.     定义路径：/usr/include/libio.h

9.     别名(typedef)：/usr/include/stdio.h

10. 打开流

头文件: #include <stdio.h>

定义函数：

              FILE* fopen(const char *pathname,const char*mode);

函数说明：

        pathname: 文件的路径及文件名。

        mode: 流的打开方式。

返回值：

        成功：返回指向该流的指针。

        失败：则返回NULL，并把错误代码存在errno中

11. 关闭流

头文件：#include <stdio.h>

定义函数：

              int fclose(FILE *stream);

函数说明：

       fclose用来关闭fopen打开的文件。此动作会让缓冲区的数据写入文件中， 并释放系统所提供的文件资源。

返回值：

       成功返回0；

       失败返回EOF，并把错误代码存到errno中。

12. 读、写流

打开了流后，对其进行读写操作的方法:

       每次一个字符

       每次一行字符

       每次一个数据块

13. 每次一个字符

    int getchar(void);

    int getc(FILE *stream);

    int fgetc(FILE *stream);

 

    int putchar(int c);

    int putc(int c, FILE *stream);

    int fputc(int c, FILE *stream);

14. 每次一行字符

        char *gets(char *buf);

        char *fgets(char *buf, int n, FILE *stream);

              fgets从stream指定的文件中最多读取n-1个字符放到buf所指向的数组 中。               

             读到换行符或文件结束符后不再向后读，最后一个字符读入后接着写入一个空字符。

       返回值：

              成功返回buf；

              失败返回NULL

       注意：

              gets()丢掉输入里的换行符。

              fgets()丢掉存储输入中的换行符

        int puts(const char *str);

        int fputs(const char *str, FILE *stream);

              fputs将字符串写入stream指定的文件中，终止字符串的空字符不写入。

       返回值：

              成功返回非负数；

              失败返回EOF

       注意：

              puts()为输出添加换行符。

              fputs()不为输出添加换行符。

15. 每次一个数据块

    size_t fread(void *ptr, size_t size,size_tnobj, FILE *stream);

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

       参数：

              size是数据块大小，

              nobj指要读取或写入的数据块个数，

              stream指定要操作的数据流。

       注意：

              两个函数返回的是实际读或写的数据块的个数，而不是整个数据的字节数。

16.读写位置函数

#include <stdio.h>

int fseek(FILE *stream,longoffset,int whence);

long ftell(FILE *stream);

void rewind(FILE *stream);

1）fseek:移动文件内部的指针

int fseek(FILE *stream,long offset,int whence);

参数：

stream指向被移动的文件

offset表示移动的字节数，当用差常量表示位移量时，后缀加L

whence用于计算偏移量的相对位置

起始点	符号表示	数字表示
文件首	SEEK_SET	0
当前位置	SEEK_CUR	1
文件末	SEEK_END	2

注：fssek一般用于二进制文件

2）ftell：得到stream指定的流式文件的当前位置，用于相对文件开头的位移量表示

long ftell(FILE *stream);

参数：指向文件

返回值：

成功，当前的位移量

失败，返回-1

例：n=ftell(fd);

3）rewind(FILE *stream);使位置指针返回文件的开头，无返回值

17. int fflush(FILE *stream)实现将缓冲区尚未写入文件的数据强制写入文件，然后清空缓冲区

   若果stream为NULL，则更新所有打开的文件数据

    fflush(stdin)刷新标准输入缓冲区，fflush(stdout)刷新标准输出缓冲区  

例子：fread fwirte fgets fputs 读取写入数据，之后读取全部文件数据

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    int buff_length;
    FILE* fd;
    char* path = "/home/liang/MyLearn/file/text";
    char buff[BUFSIZ];
    printf("程序开始n");

    //以可读可写方式打开文件
    if ( (fd = fopen(path,"w+")) < 0){
        perror("打开失败n");
        return -1;
    }
    printf("打开文件：%sn",path);

    /*********************字符块读写*************************/
    printf("请输入要写入文件的字符块：");
    scanf("%s",buff);
    //从fd中输入buff的内容
    buff_length = strlen(buff);
    if( fwrite(buff,buff_length,1,fd) != 1 ){
        perror("写入文件失败");
        return -1;
    }
    printf("写入成功n");

    rewind(fd);//定位到文件开头
    //从fd中读取BUFSIZ个字符到buff
    if( fread(buff,buff_length,1,fd) != 1 ){
        perror("读取失败n");
        return -1;
    }
    printf("读取数据：%sn",buff);
    /***********************字符串读写******************/
    int position;
    position = ftell(fd);//记录文件指针位置
    printf("请输入要写入文件的字符串：");
    scanf("%s",buff);
    //从fd中输入buff的内容
    if( fputs(buff,fd) == EOF ){
        perror("写入文件失败");
        return -1;
    }
    printf("写入成功n");

    fseek(fd,position,0);//定位到记录位置
    //从fd中读取BUFSIZ个字符到buff
    if( fgets(buff,sizeof(buff),fd) == NULL ){
        perror("读取失败n");
        return -1;
    }
    printf("读取数据：%sn",buff);
    /****************全部数据********************/
    rewind(fd);//定位到文件开头
    printf("全部数据:");
    while( fgets(buff,BUFSIZ,fd) != NULL )
    {
        printf("%s",buff);
    }
    printf("n");

    //关闭文件
    if(fclose(fd)<0){
        perror("关闭失败");
        return -1;
    }
    printf("关闭文件%sn",path);
    printf("程序结束n");
    return 0;
}

最后

以上就是悲凉草丛为你收集整理的Linux下文件操作 系统调用与标准I/O库的全部内容，希望文章能够帮你解决Linux下文件操作 系统调用与标准I/O库所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。