Linux文件编程

最新推荐文章于 2023-07-11 21:50:28 发布
最新推荐文章于 2023-07-11 21:50:28 发布
阅读量184 收藏
点赞数
分类专栏： LInux文件编程 文章标签： linux ubuntu Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58985552/article/details/129153413
版权

在windows中手动修改文件操作步骤：打开\创建文档，编辑文档，保存文档，关闭文档。在Linux中就是用代码操作文件使计算机自动化完成以上步骤。

Linux为此提供了一系列API，打开\创建文件：open，读写：write\read，光标定位：lseek，关闭：close

文件的打开

  1. 需要包含的头文件：使用man查询open，可以看到要使用open必须包含3个头文件，分别是：<sys/types.h>,<sys/stat.h>,<fcntl.h>

  1. 返回值：open函数有整数返回值，返回文件的文件描述符，用来区分不同的文件，相当于文件的索引。当文件打开成功时，返回的是非负整数，打开失败时返回负数

  1. 参数含义：

pathname：要打开的文件名（含路径，缺省位当前路径）

flags：打开方式，有三种方式，分别是O_RDONLY只读打开， O_WRONLY只写打开， O_RDWR 可读可写打开。

当附带了权限后，打开的文件就只能按照这种权限来操作，比如，我使用O_RDONLY打开文件之后，我不能对文件进行写操作，我只能读

以上3个参数中应当只指定一个，下列的参数是可以选择的：

  1. O-CREAT 若文件不存在则创建它。使用此选项是，需要同时说明第三个参数mode，用其说明该新文件的存取许可权限

  1. O_EXCL 如果同时制定了OCREAT，而文件已经存在，则返回-1

  1. O_APPEND 每次写时都加到文件的尾端

  1. O_TRUNC 若文件种本来有内容，而且位只读或只写成功打开，则将其长度截短为0

mode：一定是再flags中使用了O_CREAT标志，mode记录待创建的文件的访问权限。

  1. 作用：打开一个文件，并返回该文件的文件描述符，以便于对其进行读写等操作

  1. 相关应用

//打开当面目录下的file1文件

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

int main()
{
        int fd;
        fd=open("./file1",O_RDWR);
        printf("fd=%d\n",fd);
        return 0;
}

创建file1，使用可读可写的方式打开file1文件，编译运行，可以看到返回值为3

删除file1，再运行代码对其进行打开操作，返回值为-1

//打开当前目录下的file1文件
//当打开文件失败时，创建该文件

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

int main()
{
        int fd;

        fd=open("./file1",O_RDWR);

        if(fd==-1){
                printf("open file1 failed\n");
                fd=open("./file1",O_RDWR|O_CREAT,0600);//0600是文件的访问权限为文件所有者可读可写

                if(fd>0){
                        printf("create file1 successed\n");
                }
        }
        return 0;
}

文件的创建

  1. 需要包含的头文件：<sys/types.h>, <sys/stat.h>, <fcntl.h>

  1. 返回值：fd文件描述符

  1. 参数含义：

pathname：要创建的文件名（含路径，缺省位当前路径）

mode：创建模式

  1. S_IRUSR: 可读

  1. S_IWUSR: 可写

  1. S_IXUSR: 可执行

  1. S_IRWXU: 可读可写可执行

  1. 作用：从buf缓冲区中写入count个字节到文件中

  1. 相关应用：

//在当前目录下创建一个可读可写可执行得到file2文件

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

int main()
{
        int fd;
        char *buf="write file";
        fd =creat("./file2",S_IRWXU);

        return 0;
}

文件写入操作

  1. 需要包含的头文件：<unistd.h>

  1. 返回值：写入成功，返回写入的字节个数，写入失败返回-1

  1. 参数含义：fd：文件描述符，buf：缓冲区 ，count：写入字节数

  1. 作用：从buf缓冲区中写入count个字节到文件中

  1. 相关应用：

//将“write file”写入file1文件中

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
int main()
{
        int fd;
        char *buf="write file";

        fd=open("./file1",O_RDWR);
        if(fd==-1){
                printf("open file1 failed\n");
                fd=open("./file1",O_RDWR|O_CREAT,0600);
                if(fd>0){
                        printf("create file1 successed\n");
               }
        }
        printf("open success  fd=%d\n",fd);
        write(fd,buf,strlen(buf));//此处不能使用sizeof，必须使用strlen，sizeof计算的是buf指针的大小，strlen计算的才是指针指向内容的字节大小
        close(fd);
        return 0;
}

文件读取操作

  1. 需要包含的头文件：<unistd.h>

  1. 返回值：读取成功，读到多少字节就返回多少；读取失败返回0；读取错误返回-1

  1. 参数含义：fd：文件描述符，buf：缓冲区 ，count：读取字节数

  1. 作用：从文件中读取count个字节到buf缓冲区

  1. 相关应用：

//读取file1文件中的内容

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

int main()
{
        int fd;
        char *buf="write file";

        fd=open("./file1",O_RDWR);
        if(fd==-1){
                printf("open file1 failed\n");
                fd=open("./file1",O_RDWR|O_CREAT,0600);
                if(fd>0){
                        printf("create file1 successed\n");
                }
        }
        printf("open success  fd=%d\n",fd);

        int cnt_write=write(fd,buf,strlen(buf));
        if(cnt_write !=-1){
                printf("write %d byte to file1\n",cnt_write);
        }

        close(fd);
        fd=open("./file1",O_RDWR);//此处关闭文件再重新打开的目的是让光标重新回到文件头，这样才能读取到写入的内容，也可以使用光标重定位lseek来进行此操作

        char *readBuf;
        readBuf=(char *)malloc(sizeof(char)*cnt_write+1);//这里必须对readBUf进行空间开辟，不然readBuf没有具体的指向，会发生段错误。

        int cnt_read=read(fd,readBuf,cnt_write);//读取的大小不一定必须是写入的大小，可以是任意值，但是读取到的内容，只有写入的内容那么大，比如读取的是100字节，但是读取完之后的内容依然只有10字节
        printf("read %d ,context:%s\n",cnt_read,readBuf);

        close(fd);
        return 0;
}

文件光标移动操作

在进行读取时，我们使用了关闭文件再重新打开文件的方式，这种方式就有点垃圾了，我们可以使用lessk直接移动光标

  1. 需要包含的头文件：<sys/types.h>,<unistd.h>

  1. 返回值：调用成功，返回对于文件头的偏移值

  1. 参数含义：

fd：文件描述符

offset：当offset为负数，对于whence往前移，当offset为正数，对于whence往后移

whence：

  1. SEEK_SET：文件头

  1. SEEK_CUR：当前位置

  1. SEEK_END：文件尾

  1. 作用：将文件读写指针相对whence移动offset个字节

  1. 相关应用：

//对于前面的读取文件内容的代码，进行修改

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

int main()
{
        int fd;
        char *buf="write file";

        fd=open("./file1",O_RDWR);
        if(fd==-1){

                printf("open file1 failed\n");
                fd=open("./file1",O_RDWR|O_CREAT,0600);
                if(fd>0){

                        printf("create file1 successed\n");
                }

        }
        printf("open success  fd=%d\n",fd);

        int cnt_write=write(fd,buf,strlen(buf));
        if(cnt_write !=-1){
                printf("write %d byte to file1\n",cnt_write);
        }
//      close(fd);      
//      fd=open("./file1",O_RDWR);   

        lseek(fd,-cnt_write,SEEK_END);//从文件尾像前移动写入的字节数，也相当于lssek(fd,0,SEEK_SET)

        char *readBuf;
        readBuf=(char *)malloc(sizeof(char)*cnt_write+1);

        int cnt_read=read(fd,readBuf,cnt_write);
        printf("read %d ,context:%s\n",cnt_read,readBuf);

        close(fd);
        return 0;
}

//巧用lseek对文件大小进行计算

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

int main()
{
        int fd;
        char *buf="write file";

        fd=open("./file1",O_RDWR);

        int fileSize=lseek(fd,0,SEEK_END);//利用lseek的返回值是对于文件头的偏移值，我们可以直接将光标移到文件尾，就可以巧妙的计算文件的字节大小了

        printf("file size is:%d\n",fileSize);

        close(fd);
        return 0;
}

文件编程应用1——实现Linux cp命令

//main函数的参数，来读取cp aa bb命令中的两个文件

#include <stdio.h>

int main(int argc, char **argv) //argc是参数的总个数，argv是数组指针，每个数组指针指向的内容是相应的参数
{
        printf("total paeams:%d",argc);
        printf("No.1 params:%s\n",argv[0]);
        printf("No.2 params:%s\n",argv[1]);
        printf("No.3 params:%s\n",argv[2]);
        return 0;
}
//编写代码实现Linux cp命令
/*实现思路：打开源文件src.c，读源文件src.c到缓冲区buf，打开/创建目标文件des.c，将缓冲区buf的内容写入到目标des.c，关闭两个文件*/

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
        int fd_src;
        int fd_des;
        char *readBuf=NULL;
        if(argc !=3){
                printf("param error\n");
                exit(-1);
        }

        fd_src=open(argv[1],O_RDWR);
        int size=lseek(fd_src,0,SEEK_END);
        lseek(fd_src,0,SEEK_SET);
        readBuf=(char *)malloc(sizeof(char)*size+8);

        int n_read=read(fd_src,readBuf,size);
        fd_des=open(argv[2],O_RDWR|O_CREAT|O_TRUNC,0600);
        int n_write=write(fd_des,readBuf,strlen(readBuf));

        close(fd_src);
        close(fd_des);
        return 0;
}

文件编程应用2——修改程序的配置文件

在这之前需要先了解strstr()这个API

  1. 需要包含的头文件：<string.h>

  1. 返回值：需要找的特定字符串出现的首位置，返回的是一个字符型指针

  1. 参数含义：haystack：要操作的字符串 ，needle：找到的字符串

  1. 作用：从字符串中找出特定的字符串

现有配置文件如下，将LENG=3 修改为 LENG=5

//修改LENG=3为LENG=5的步骤如下
//1.找到LENG=3出现的首位置
//2.该位置记录下来
//3.再将位置向后移动到需要修改的地方，即移动到3的位置，再将5赋值给指针指向的位置

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
        int fd_src;
        char *readBuf=NULL;
        if(argc !=2){
                printf("param error\n");
                exit(-1);
        }

        fd_src=open(argv[1],O_RDWR);
        int size=lseek(fd_src,0,SEEK_END);
        lseek(fd_src,0,SEEK_SET);
        readBuf=(char *)malloc(sizeof(char)*size+8);

        int n_read=read(fd_src,readBuf,size);

        char *p=strstr(readBuf,"LENG=");

        if(p==NULL){
                printf("not found");
                exit(-1);
        }

        p=p+strlen("LENG+");
        *p='5';//一定要是字符'5'，在文件中的内容都是字符型的

        lseek(fd_src,0,SEEK_SET);//光标重新定位，让缓冲区中修改后的内容重新覆盖掉源文件中的内容
        int n_write=write(fd_src,readBuf,strlen(readBuf));

        close(fd_src);
        return 0;
}

编译运行之后，再打开需要修改的文件，就可以看到已经修改好了

写一个整数到文件

上面修改文件配置文件时，写入文件的是一个字符，并且文件中的内容都是字符型的，那么怎样才能将一个整型数写入到文件呢

可以从手册中看到，buf其实是一个无类型的指针，所以不仅仅是可以传递一个字符型指针，也可以是一个指向整型数的地址

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
        int fd;
        int x=100;
        int y=0;
        fd=open("./file2",O_RDWR);
        int n_write=write(fd,&x,sizeof(int));//将x地址指向的值写入到file2里面
        lseek(fd,0,SEEK_SET);//光标重定位，将光标定位到文件头
        int n_read=read(fd,&y,sizeof(int));//从file2中将x读到y所指向的地址空间中
        printf("read:%d",y);        
        close(fd);
        return 0;
}

写结构体数组到文件

  1. 写结构体到文件

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

struct test
{
        int a;
        char b;
};

int main()
{
        int fd;
        struct test x={100,'a'};
        struct test y;
        fd=open("./file2",O_RDWR);
        int n_write=write(fd,&x,sizeof(struct test));
        lseek(fd,0,SEEK_SET);
        int n_read=read(fd,&y,sizeof(struct test));
        printf("read:%d,%c\n",y.a,y.b);
        close(fd);
        return 0;
}

  1. 写结构体数组到文件

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

struct test
{
        int a;
        char b;
};

int main()
{

        int fd;
        struct test x[2]={{100,'a'},{101,'b'}};
        struct test y[2];
        fd=open("./file2",O_RDWR);
        int n_write=write(fd,&x,sizeof(struct test)*2);
        lseek(fd,0,SEEK_SET);
        int n_read=read(fd,&y,sizeof(struct test)*2);
        printf("read:%d,%c\n",y[0].a,y[0].b);
        printf("read:%d,%c\n",y[1].a,y[1].b);
        close(fd);
        return 0;
}

以此类推，也可以将链表等写入到文件中

标准C库打开创建文件读写光标移动

#include <stdio.h>
#include <string.h>
int main()
{

        FILE *fp;
        char readBuf[1024]={0};
        char *str="write file";

        fp=fopen("./file1","w+");
        fwrite(str,sizeof(char),strlen(str),fp);
        fseek(fp,0,SEEK_SET);
        fread(readBuf,sizeof(char),strlen(str),fp);
        printf("read data: %s\n",readBuf);
        fclose(fp);
        return 0;
}

XXX_MRX
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fopen与open的区别（比面可能考）
weixin_44372427的博客
07-23 343
来源 从来源的角度看，两者能很好的区分开，这也是两者最显而易见的区别： open是UNIX系统调用函数（包括LINUX等），返回的是文件描述符（File Descriptor），它是文件在文件描述符表里的索引。 fopen是ANSIC标准中的C语言库函数，在不同的系统中应该调用不同的内核api。返回的是一个指向文件结构的指针。 PS:从来源来看，两者是有千丝万缕的联系的，毕竟C语言的库函数还是需要调用系统API实现的。 移植性 这一点从上面的来源就可以推断出来，fopen是C标准函数，因此拥有良好的.
open(/dev/ietctl, O_RDWR) 参数含义
yubin1023的专栏
01-24 2467
原文来自：http://bbs.ednchina.com/BLOG_ARTICLE_2039537.HTM 这是文件I/O的常用函数，open函数，open函数用来打开一个设备，他返回的是一个整型变量，如果这个值等于-1，说明打开文件出现错误，如果为大于0的值，那么这个值代表的就是文件描述符。一般的写法是if((fd=open("/dev/ttys0",O_RDWR | O_NOCTTY | O
【看表情包学Linux】系统下的文件操作 | 文件系统接口 | 系统调用与封装 | open,write,close 接口 | 系统传递标记位 O_RDWR,O_RDONLY,O_WRONLY...
有道无术, 术尚可求。有术无道, 止于术。
03-18 3239
本章我们将正式接触系统接口 (syscall)，为斯坦福大学官方 OS 项目Pintos 做铺垫，系统调用是非常重要的前置知识。本篇主要讲解底层文件系统接口，详细介绍 open 接口和它的 flags 参数 (即系统传递标记位)，重点讲解O_RDWR, O_RDONLY, O_WRONLY, O_CREAT 和 O_APPEND 这些操作模式。flags 标记位这一块的知识点，再一次出现了对 "位图" 的使用，这一块的知识点尤为重要，后期可能会大量涉及这样的设计手法。然后再顺带讲解 close 接口和
Linux 基础I/O
weixin_62688907的博客
10-31 901
记录的信息主要有：bolck 和 inode的总量，未使用的block和inode的数量，一个block和inode的大小，最近一次挂载的时间，最近一次写入数据的时间，最近一次检验磁盘的时间等其他文件系统的相关信息。当文件没有被打开的时候，文件在磁盘中，但当一个文件被打开后，文件会被读取到内存中，一个进程可以打开多个文件，而这些打开的文件操作系统需要很好的管理，所以一个文件打开，会先创建对应的内核数据结构，而操作系统会把一个进程打开的所有文件通过链表连接起来，这样对打开文件的管理变成了对链表的增删查改，
Linux中的O_RDONLY、O_WRONLY、O_RDWR、O_APPEND、O_TRUNC、O_EXCL、O_EXCL、O_SYNC、O_NONBLOCK
m0_61629312的博客
07-11 5541
O_CREAT:在文件打开过程中创建新文件O_RDONLY：以只读方式打开文件。O_WRONLY：以只写方式打开文件。O_RDWR：以读写方式打开文件。O_APPEND：在文件末尾追加数据，而不是覆盖现有内容。O_TRUNC：如果文件已经存在，将其截断为空文件。O_EXCL：与 O_CREAT 一起使用时，如果文件已经存在，则 open() 调用将失败。O_SYNC：使文件写操作变为同步写入，即将数据立即写入磁盘。
LINUX_c_SOURCE.zip_linux文件编程
09-20
linux C 编程入门，包括网络编程，可视化，进程管理，文件操作等
linux文件编程
12-16
这是一个linux中有关文件编程的所有代码，可以实现，非常具有参考价值
LINUX文件编程
12-06
LINUX文件编程
linux文件编程.pdf
09-30
linux文件编程.pdf
linux 文件编程例子
01-12
三个简单的文件编程例子，linux的open() read() write()函数等 含一个文件拷贝程序。适合初学者
操作系统：文件IO
Shilong的博客
10-21 1120
操作系统之文件IO
linux文件操作--学习笔迹1
stm32_c的博客
07-28 824
open
文件I/O编程
weixin_45373745的博客
04-20 1130
I/O文件编程常用函数
文件操作篇——打开 读写 关闭操作
qq_51938263的博客
12-18 1339
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： 1.O_RDONLY：只读打开 2.O_WRONL
第十六篇，LINUX文件IO编程概念以及系统IO函数open,close,read,write使用。
weixin_44651073的博客
02-24 1449
一、linux IO编程学习大纲。 1、文件IO概念、文件概念、文件类型。 2、系统IO --> 如何使用系统IO接口访问/写入/读取/关闭文件。 3、系统IO文件描述符的概念？文件描述符与文件的关系？研究文件描述符的值。 4、文件偏移量。 5、系统IO应用实例：lcd液晶设备、触摸屏。 6、系统IO另外一个处理lcd液晶设备方式：内存映射。 7、标准IO --> 如何使用标准IO接口访问/写入/读取/关闭文件。 8、标准IO --> 一系列处理字符/字符串函数。 9、标准IO应用实...
Linux文件创建——open/creat函数，功能O_RDWR|O_CREAT|O_EXCL|O_APPEND|O_TRUNC
热门推荐
举子人间
03-21 1万+
O_CREAT 函数已经用过了，若不存在就新建一个文件 我们来看看 O_EXAL 函数吧（若文件存在，则返回-1） #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> #include<stdlib.h> #include<fcntl.h> #include<stdio.h> int main() { int fd; f.
文件：打开或者创建
qq_41962968的博客
06-14 644
1.文件打开函数原型： int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode); 返回值是int 型，一般用 fd 接收，叫作文件描述符，例如：fd = open("./file",O_RDWR); 打开成功返回一个非负整数，打开失败返回-1； 2.参数描述： Pathname:要打开的文件名（...
Linux-文件-笔记
qq_56319128的博客
06-08 345
操作系统ti'g 打开open 读写write/read 光标定位 lseek 关闭close
Linux文件编程（1）
m0_57440581的博客
03-06 484
1.打开并创建文件 必须包含的头文件 #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); int creat(const char *pathname, mode_t mode);
linux 文件编程
最新发布
06-13
Linux文件编程，也称为文件系统编程或I/O（Input/Output）编程，是指在Linux环境下开发程序，与操作系统内核中的文件系统进行交互的过程。它涉及到对文件的操作，如读取、写入、创建、删除、移动和重命名文件等。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值