Linux 文件系统编程之系统调用和标准I/O库

最新推荐文章于 2019-01-16 15:00:00 发布
最新推荐文章于 2019-01-16 15:00:00 发布
阅读量344 收藏 1
点赞数 1
分类专栏： 苏嵌学习 文章标签： 函数 path 文件系统 编程 标准
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/believe_s/article/details/77012387
版权

系统调用

访问设备驱动程序的底层函数主要有：
open:打开文件或者设备。
read:从打开的文件或者设备里面读取数据。
write:向文件或者设备写数据。
close:关闭文件或者设备。
open系统调用：
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int open (const char *path, int flags);
int open (const char *path, int flags, mode_t mode);
path表示文件名，flags用来定义准备对打开的文件进行操作的动作。
如果open调用成功，则返回一个新的文件描述符（非负整型）；如果失败，就返回-1。


close系统调用：
#include <unistd.h>
int close(int filedes);
成功返回0；出错返回-1；

read系统调用：
#include <unistd.h>
ssize_t read(int filedes, const void *buf, size_t nbytes);< publishblog.blogchina.com http:>
将n个字节从文件描述符对应的文件读出放入到buf中。成功则返回实际的读取字节数。

write系统调用：
#include <unistd.h>
ssize_t write(int filedes, const void *buf, size_t nbytes);
返回值是实际写入的字节数（可能会小于nbytes）；如果返回值是0，表示没有写入任何数据；如果返回值是-1，表示在write调用中出错了。
将n个字节从buf中写入到文件描述符对应的文件中。

常用标准I/O库文件函数：fopen,fwrite,fread,fclose,fflush,fseek,fgets,getchar,fputs等系列的函数
他们与系统调用的一个主要的区别在于，这是带缓冲的函数，操作的对象不是int型的文件描述符，而是fopen返回的FILE型的文件指针（*fp）.对应的标准输入，输出，出错为stdin,stdout,stderr文件指针。
我把这些函数的用法全都写在这里：

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <time.h>

#define SIZE  1024

// fopen
int main0()
{
    FILE* fp = fopen ("abc", "ab+");
    if (NULL == fp)
    {
        perror ("fopen");
        return -1;
    }

    printf ("打开文件成功\n");
    return 0;
}

// fread
int main1()
{
    FILE* fp = fopen ("BTree.c", "ab+");
    if (NULL == fp)
    {
        perror ("fopen");
        return -1;
    }

    char buf[SIZE] = {0};

    // feof 判断是否读到文件结尾，如果读到文件结尾，它返回一个非0 的值
    int ret;
    while (ret = fread (buf, sizeof(char), SIZE-1, fp))
    {
        buf[ret*sizeof(char)] = '\0';
        printf ("%s\n", buf);
    }

    if (0 == ret && !feof(fp))
    {
        perror ("fread");
        return -1;
    }

    printf ("文件读取结束\n");
    return 0;
}

// fwrite
int main2()
{
    FILE* fp = fopen ("1.ppt", "ab+");
    if (NULL == fp)
    {
        perror ("fopen");
        return -1;
    }

    FILE* fp1 = fopen ("2.ppt", "ab+");
    if (NULL == fp1)
    {
        perror ("fopen");
        return -1;
    }

    char buf[SIZE] = {0};

    // feof判断是否读到文件结尾，如果读到文件结尾，它返回一个非0 的值
    int ret;
    while (ret = fread (buf, sizeof(char), SIZE, fp))
    {
        fwrite (buf, sizeof(char), ret, fp1);
    }

    if (0 == ret && !feof(fp))
    {
        perror ("fread");
        return -1;
    }

    printf ("文件读取结束\n");

    fclose (fp);
    fclose (fp1);
    return 0;
}

// fgetc
int main3()
{
    FILE* fp = fopen ("1.ppt", "ab+");
    if (NULL == fp)
    {
        perror ("fopen");
        return -1;
    }

    FILE* fp1 = fopen ("2.ppt", "ab+");
    if (NULL == fp1)
    {
        perror ("fopen");
        return -1;
    }

    char buf[SIZE] = {0};

    // feof 判断是否读到文件结尾，如果读到文件结尾，它返回一个非0 的值
    int ret;
    while(1)
    {
        int  c = fgetc (fp);
        if (EOF == c)
        {
            break;
        }
        fputc (c, fp1);
    }

    fclose (fp);
    fclose (fp1);
    return 0;
}

// 数据获取
/***************************************************************/
typedef struct student
{
    int id;
    char name[20];
}STU;


void write_data(STU* a, int len)
{
    FILE* fp = fopen ("student", "ab+");
    if (NULL == fp)
    {
        perror ("fopen");
        return;
    }   

    // 要写入个数
    fwrite (&len, sizeof(int), 1, fp);

    int i;
    for (i = 0; i < len; i++)
    {
        // 写入数据长度
        len = sizeof(a[i]);     
        fwrite (&len, sizeof(int), 1, fp);

        // 写入数据
        fwrite (&a[i], sizeof(STU), 1, fp);
    }

    fclose (fp);
}


// 读取数据
void read_data()
{
    FILE* fp = fopen ("student", "ab+");
    if (NULL == fp)
    {
        perror ("fopen");
        return;
    }

    // 读记录的个数
    int count;
    fread (&count, sizeof(int), 1, fp);

    printf ("记录个数是:%d\n", count);
    int i;
    STU tmp;
    for (i = 0; i < count; i++)
    {
        int len;
        fread (&len, sizeof(int), 1, fp);

        // 读取数据
        fread (&tmp, len, 1, fp);
        printf ("id = %d, name = %s\n", tmp.id, tmp.name);
    }

    fclose (fp);
}

int main4()
{
    int i;
    STU a[20];

    for (i = 0; i < 20; i++)
    {
        a[i].id = i;                
        sprintf (a[i].name, "zhang%d", i);
    }

    int len = sizeof(a)/sizeof(a[0]);   

    // 写数据
    write_data(a, len);

    // 读数据
    read_data();

    return 0;
}
/***************************************************************/


// open
int main5()
{
    close(1);

    // 打开一个文件
    int fd = open ("test.txt", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR |   S_IXUSR);
    // int fd = open("test.txt", O_RDONLY);

    if (-1 == fd)
    {
        printf ("打开文件失败\n");
        perror ("open");
        printf ("%s\n", strerror(errno));          
    }

    printf ("fd = %d\n", fd);
    printf ("asdadsafsfkj\n", fd);
    printf ("asdadsafsfkj\n", fd);
    printf ("asdadsafsfkj\n", fd);
    printf ("asdadsafsfkj\n", fd);
    printf ("asdadsafsfkj\n", fd);
    printf ("asdadsafsfkj\n", fd);
    printf ("asdadsafsfkj\n", fd);
    // fflush(stdout);

    close(fd);

    return 0;

}

// read
/***************************************************************/
int main6()
{
    int fd = open ("BTree.c", O_RDONLY, 0777);
    if (-1 == fd)
    {
        perror ("open");
        return -1;
    }

    // 缓冲区  
    char buf[SIZE] = {0};
    ssize_t ret = read (fd, buf, SIZE-1);
    if (-1 == ret)
    {
        perror ("read");
    }

    // 返回值为0 代表读到文件结尾
    if (0 == ret)
    {
        printf ("文件读取结束\n");
    }

    printf ("len = %d\n", strlen(buf));
    printf ("读到%d字节：%s\n", ret, buf);

    return 0;
}

// 缓冲区覆盖问题
int main7()
{
    int fd = open ("BTree.c", O_RDONLY, 0777);
    if (-1 == fd)
    {
        perror ("open");
        return -1;
    }

    char buf[SIZE] = {0};

    while(1)
    {
        ssize_t ret = read (fd, buf, SIZE-1);
        if (-1 == ret)
        {
            perror ("read");
        }

        // 返回值为0 代表读到文件结尾
        if (0 == ret)
        {
            printf ("文件读取结束\n");
            break;
        }

        // printf ("len = %d\n", strlen(buf));
        // printf ("读到%d 字节： %s\n", ret, buf);
        printf ("%s", buf);
    }

    return 0;
}

// 读取数据之前清空缓冲区
int main8()
{
    int fd = open ("BTree.c", O_RDONLY, 0777);
    if (-1 == fd)
    {
        perror ("open");
        return -1;
    }

    char buf[SIZE] = {0};

    while(1)
    {
        memset (buf, 0, SIZE);          // 清空缓冲区
        ssize_t ret = read (fd, buf, SIZE-1);
        if (-1 == ret)
        {
            perror ("read");
        }

        if (0 == ret)
        {
            printf ("文件读取结束\n");
            break;
        }
        printf ("%s", buf); 
    }

    return 0;
}

// 每次读完数据之后讲下一个字节置为'\0';
int main9()
{
    int fd = open ("BTree.c", O_RDONLY, 0777);
    if (-1 == fd)
    {
        perror ("open");
        return -1;
    }

    char buf[SIZE] = {0};

    while(1)
    {
        ssize_t ret = read (fd, buf, SIZE-1);
        if (-1 == ret)
        {
            perror ("read");
        }

        if (0 == ret)
        {
            printf ("文件读取结束\n");
            break;
        }

        buf[ret] = '\0';
        printf ("%s", buf);
        }

        return 0;
}

// 读一个完整的大数据
int main10()
{
    int fd = open ("BTree.c", O_RDONLY, 0777);
    if (-1 == fd)
    {
        perror ("open");
        return -1;
    }

    char buf[SIZE] = {0};
    char* p = buf;
    int count = SIZE - 1;               // 每次要读的数据个数
    ssize_t ret =0;
    while (ret = read (fd, p, count))
    {
        // 出错
        if (-1 == ret)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                continue;
            }
            break;
        }
        printf ("sfjsfsjfs\n");
        // 读完
        if (ret == count)
        {
            break;
        }
        count -= ret;                   // 下一次要读的数据
        p += ret;
    }

    printf ("len = %d\n", strlen(buf));
    // printf ("%s\n", buf);

    return 0;
}
/***************************************************************/


// write
int main11()
{
    int fd = open ("abc", O_WRONLY|O_CREAT, 0777);
    if (-1 == fd)
    {
        perror ("open");
        return -1;
    }
    char buf[SIZE] = {0};

    while(1)
    {
        fgets (buf, SIZE, stdin);
        if (0 == strncmp ("end", buf, 3))
        {
            break;
        }

        ssize_t ret = write (fd, buf, strlen(buf));
        if (-1 == ret)
        {
            perror ("write");
        }

        printf ("要写的字节数：%d，实际写的字节数：%d\n", SIZE, ret);
    }

    close(fd);
    return 0;
}

// 文件复制
int main12()
{
    // 打开要读的文件
    int fd1 = open ("1.ppt", O_RDONLY);
    if (-1 == fd1)
    {
        perror ("open fd1");
        return -1;
    }

    int fd2 = open ("2.ppt", O_WRONLY|O_CREAT, 0777);
    if (-1 == fd2)
    {
        perror ("open fd2");
        return -1;
    }

    int ret = 0;
    char buf[SIZE] = {0};
    while (ret = read (fd1, buf, SIZE))
    {
        if (-1 == ret)
        {
            perror("read");
            break;
        }

        write (fd2, buf, ret);
    }
    printf ("文件复制完成\n");
    close (fd1);
    close (fd2);

    return 0;
}

// lseek
int main13()
{
    // 打开要读的文件
    int fd = open ("abc2", O_RDWR|O_CREAT, 0777);
    if (-1 == fd)
    {
        perror ("open fd1");
        return -1;
    }

    // 设置这个文件的偏移指针
    lseek (fd, 20, SEEK_SET);

    char* buf = "hello";

    write (fd, buf, strlen(buf));
    close (fd);

    return 0;
}

// 创建一个大文件
int main14()
{
    // 打开要读的文件
    int fd = open ("big", O_RDWR|O_CREAT, 0777);
    if (-1 == fd)
    {
        perror ("open fd1");
        return -1;
    }

    // 设置这个文件的偏移指针到1G处
    lseek (fd, 1024*1024*1024, SEEK_SET);

    char* buf = "hello";    
    write (fd, "a", 1);
    close (fd);

    return 0;
}

// printf缓冲
int main15()
{
    while(1)
    {
        printf ("a");
        usleep (2000);
    }

    return 0;
}

// 文件偏移指针测试1
int main16()
{
    // 打开要读的文件
    int fd = open ("big", O_RDWR|O_CREAT, 0777);
    if (-1 == fd)
    {
        perror("open fd1");
        return -1;
    }

    printf ("%d\n", fd);
    // 设置这个文件的偏移指针到1G处
    lseek (fd, 20, SEEK_SET);

    printf ("等待2些数据\n");
    getchar();

    char* buf = "hello";

    write (fd, "a", 1);
    getchar();

    close (fd);
    return 0;
}

// 文件偏移指针测试2
int main17()
{
    // 打开要读的文件
    int fd1 = open ("abc", O_RDWR|O_CREAT, 0777);
    if (-1 == fd1)
    {
        perror ("open fd1");
        return -1;
    }

    printf ("abc fd = %d\n", fd1);

    int fd = open ("big", O_RDWR|O_CREAT, 0777);
    if (-1 == fd)
    {
        perror ("open fd");
        return -1;
    }

    printf ("bif fd = %d\n", fd);
    // 设置这个文件的偏移指针到 1G处
    lseek (fd, 10, SEEK_SET);

    char *buf = "12345";

    write (fd, buf, strlen(buf));
    getchar();
    close (fd);

    return 0;
}

/***************************************************************/
// 随机分组
// 函数功能：互换
void swap (int* a, int i, int j)
{
    int tmp = a[i];
    a[i]    = a[j];
    a[j]    = tmp;
}
// 函数功能：打印
void printA (int* a, int len)
{
    int i;

    for (i = 0; i < len; i++)
    {
        if (0 == i % 4)
        {
            printf ("\n");
        }
        printf ("%4d", a[len-i-1]);
    }

    putchar ('\n');
}

int main18()
{
    srand ((unsigned int)time(NULL));

    int a[40];
    int i;
    int len = 40;
    for (i = 0; i < 40; i++)
    {
        a[i] = i;
    }

    for (i = len-1; i > 0; i--)
    {
        int index = rand() % (i+1);    // 获取随机数
        swap (a, index, i);            // 将获得的数和最后一个互换
    }

    printA (a, len);

    return 0;
}
/***************************************************************/
believe_s
关注
专栏目录
Linux系统编程（1）——文件与I/O之C标准I/O函数与系统调用I/O
尹成的技术博客
07-24 4596
Linux系统的I/O也就是一般所说的低级I/O——操作系统提供的基本IO服务，与os绑定，特定于Linux平台。而标准I/O是ANSI C建立的一个标准I/O模型，是一个标准函数包和stdio.h头文件中的定义，具有一定的可移植性。两者一个显著的不同点在于，标准I/O默认采用了缓冲机制，比如调用fopen函数，不仅打开一个文件，而且建立了一个缓冲区（读写模式下将建立两个缓冲区），还创建了一个包含
文件I/O和标准I/O的区别
热门推荐
知秋一叶
01-01 1万+
一、先来了解下什么是文件I/O和标准I/O： 文件I/O：文件I/O称之为不带缓存的IO（unbuffered I/O)。不带缓存指的是每个read，write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务，与os绑定，特定于linix或unix平台。 标准I/O：标准I/O是ANSI C建立的一个标准I/O模型，是一个标准函数包和stdio.h头文件
linux系统调用模块编程文件系统实验参考
03-07
实验参考电子书 有关系统调用模块编程文件系统方面的
Linux 文件操作——系统调用和标准I/O库
haierboos
08-18 411
一、什么是文件 在讲述文件操作之前，我们首先要知道什么是文件。看到这个问题你可能会感觉到可笑，因为对于用过计算机的人来说，文件是最简单不过的概念了，例如一个文本是一个文件，一个work文档是一个文件等。但是在Linux中，文件的概念还远不止于这些，在Linux中，一切（或几乎一切）都是文件。文件包括很多的内容，例如：大家知道的普通文件是文件，目录也是一个文件，设备也是一个文件，管道也是一...
文件系统编程—系统调用与标准IO
flyonedream的博客
08-08 351
首先需要明白的是，所有的操作系统都提供多种服务的入口点，程序由此向内核请求服务。这些可直接进入内核的入口点被称为系统调用。 在Linux中，为了更好地保护内核空间，程序的运行空间分为内核空间和用户空间(也就是常称的内核态和用户态)，它们分别运行在不同的级别上，在逻辑上是相互隔离的。因此，用户进程在通常情况下不允许访问内核数据，也无法使用内核函数，它们只能在用户空间操作用户数据，调用用户空间的函数
Linux文件系统编程 系统调用 打开读取写入文件
weixin_39449890的博客
08-06 788
#include #include #include #include #include #include #include #define SIZE 1024 int main1() { int fd = open("BTree.c", O_RDONLY, 0777); if (fd == -1) { perror ("open");
linux系统调用之文件系统操作
weixin_30267691的博客
01-16 99
access 确定文件的可存取性 chdir 改变当前工作目录 fchdir 参见chdir chmod 改变文件方式 fchmod 参见chmod chown 改变文件的属主或用户组 fchown 参见chown lchown 参见chown chroot 改变根目录 stat...
掌握系统调用与标准I/O：Linux系统编程精要
最新发布
08-24
深入Linux系统编程的核心，探索系统调用的奥秘和标准I/O库的强大功能。《系统调用与标准I/O库》资源为您揭开了系统编程的复杂面纱，从内核到库的每个层面，提供了全面的指导和深入的解析。 系统调用概述：了解系统...
Linux C | Linux标准I/O编程
09-10
总结来说，Linux标准I/O编程是通过C语言标准库提供的函数接口，如fopen、fread、fwrite等，来实现对文件的操作，这些函数在内部使用系统调用并管理缓冲区，从而提高了程序的可移植性和效率。理解这些基础知识对于...
标准I/O库和系统调用区别（转载）
qq_33366098的博客
09-10 1777
首先，先稍微了解系统调用的概念：     系统调用，英文名system call，每个操作系统都在内核里有一些内建的函数库，这些函数可以用来完成一些系统系统调用把应用程序的请求传给内核，调用相应的的内核函数完成所需的处理，将处理结果返回给应用程序，如果没有系统调用和内核函数，用户将不能编写大型应用程序，及别的功能，这些函数集合起来就叫做程序接口或应用编程接口(Application Progra
文件操作——C库调用与Linux系统调用区别
feifei
10-09 2366
Linux下对文件操作有两种方式：系统调用(system call)和库函数调用(Library functions)。系统调用实际上就是指最底层的一个调用，在linux程序设计里面就是底层调用的意思，面向的是硬件。而库函数调用则面向的是应用开发的，相当于应用程序的api,采用这样的方式有很多种原因，第一：双缓冲技术的实现。第二，可移植性。第三，底层调用本身的一些性能方面的缺陷。第四：让api
《C Primer Plus》第6版 编程练习答案参考 第十三章(全)
Alex_mercer_boy的博客
08-24 4629
《C Primer Plus》第6版 编程练习 第十三章 目录(如果无法使用,可以选用右侧的目录选项）教程连接 先看这里(很重要！)： 函数原型:     fopen_()   ：     fgetc() 和 fputc():     rewind() 函数: 源码 + 题目 + 运行效果： Pe13-1: Pe13-2: Pe13-3： Pe13-4: Pe13-5: ...
C语言之文件编程标志I/O库（2）
ZH0314的博客
08-10 638
标志I/O库：C标准库提供了操作文件的标准I/O函数库，与系统调用相比，主要差别是实现了一个跨平台的用户态缓冲的解决方案。简单来说就是标准I/O的移植性更好。 （1） 函数fopen()： #include   // 头文件 FILE *fopen(const char *path, const char *mode);   //函数原型 fopen打开由path指定的文件，并把它与一
Linux 文件系统编程
clusterally的博客
08-10 421
Linux 文件系统编程
Linux文件操作总结（系统调用和标准IO库函数）
Plain的专栏
07-31 2483
一、用于访问设备驱动程序的底层函数
文件系统调用和Linux文件系统基础
unclerunning的博客
07-05 5061
文件系统调用和Linux文件系统基础keywords fdisk、LBA、CHS、MBR、super struct、directory、file、inode、inode table、block、file descriptor、file descriptor table、open file descriptor、open file table、mount point、vfsmount struc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值