linux下的基础IO

最新推荐文章于 2024-05-07 13:32:43 发布

不一样的博客

最新推荐文章于 2024-05-07 13:32:43 发布

阅读量332

点赞数

CC 4.0 BY-SA版权

分类专栏： Liunx

本文链接：https://blog.youkuaiyun.com/Sun_student/article/details/86413836

Liunx 专栏收录该内容

8 篇文章

订阅专栏

本文详细介绍了Linux下的基础IO操作，包括系统调用接口如open、close、write、read、lseek，以及文件描述符的概念和分配规则。还深入探讨了ext2文件系统，讲解了inode节点、软链接和硬链接的区别。此外，文章还阐述了动态库和静态库的生成方法及其链接过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Linux下IO的系统调用接口文件流指针文件描述符文件重定向

Linux下ext2文件系统 inode节点软链接/硬链接动态库和静态库的生成

1.系统调用接口： open、close、write、read、lseek

库函数和系统调用函数的关系：上下级的调用关系

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

pathname : 文件名称

flags：选项标志

必选项：O_RDONLY只读 O_WRONLY只写 O_RDWR读写

可选项：O_CREAT：若文件不存在则创建，存在则打开

O_EXCL：搭配O_CREAT使用，若文件存在则报错返回

O_APPEND：追加写

代码演示库函数：

/*c库中的io接口
 *  fopen fclose fwrite fread fseek
 */

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

int main()
{
	//mode: r r+ w w+ a a+
	//r:只读 r+：读写
	//w：只写 w+：读写  若文件不存在则创建，若问阿金存在则清空内容
	//a：写追加 a+：读写打开，追加写，从起始位置读，文件不存在则创建
	FILE* fp = fopen("./test.txt", "w+");
	if(fp == NULL){
		printf("fopen error]n");
		return-1;
	}

	char* ptr = "hello bit!!\n";
	//size_t fwrite(void* ptr, size_t size, size_t nmemb, FILE* stream);
	fseek(fp, 5, SEEK_END);
	if(fwrite(ptr, 1, strlen(ptr), fp) != strlen(ptr)){
		printf("fwirte error\n");
	}

	//int fseek(FILE* stream, long offset, int whence);
	//whence:
	//SEEK_SET  文件起始位置
	//SEEK_CUR  文件读写位置
	//SEEK_END  文件末尾位置
	fseek(fp, 0, SEEK_SET);
	//size_t fread(void* ptr, size_t size, size_t nmmeb, FILE* stream);
	char buf[1024] = { 0 };
	int ret = fread(buf, 1, 1024-1, fp);
	if(ret < 0){
		printf("read error");
	}
	printf("ret:%d buf:%s\n", ret, buf);
	fclose(fp);
	return 0;
}

代码演示系统调用接口：

/*演示基础io系统调用接口demo
 *  open close read write lseek
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

int main()
{
	//将当前进程文件创建权限掩码设置为0（仅对当前进程有效）
	//mode_t umask(mode_t mask);
	umask(0);
	//int open(const char* pathname, int flags, mode_t mode);
	//pathname:文件名称
	//flags:选项标志
	//    必选项：
	//	    O_RDONLY  只读
	//	    O_ERONLY  只写
	//	    O_RDWR    读写
	//	  可选项：
	//	    O_CREAT   若文件不存在则创建，存在则打开
	//	    O_EXCL    搭配O_CREAT使用，若文件存在则报错返回
	//	    O_TRUNC   打开文件同时清空文件内容
	//	    O_APPEND  向文件中追加内容
	//mode:权限（通常使用八进制数据表示）
	//返回值：文件描述符（非负整数） 失败：-1
	int fd = open("./test.txt", O_CREAT|O_RDWR|O_TRUNC|O_APPEND, 0664);
	if(fd < 0){
		perror("open error");
		return -1;
	}
	//ssize_t write(int fd, const void* buf, size_t count);
	//fd:文件描述符
	//buf：要写入的数据
	//count:要写入的数据长度
	//返回值:实际写入长度  失败：-1
	char* ptr = "hallo bit~~!";
	ssize_t ret = write(fd, ptr, strlen(ptr));
	if(ret < 0){
		perror("write");
		return -1;
	}

	//off_t lseek(int fd, off_t offset, int whence);
	//跳转文件读写位置到whence位置偏移offset个字节
	//whence：SEEK_SET  SEEK_CUR  SEEK_END
	lseek(fd, 0, SEEK_SET);
	char buf[1024] = { 0 };
	//ssize_t read(int fd, void* buf, size_t count);
	//返回值：实际的读取字节长度  失败;-1
	ret = read(fd, buf, 1023);
	if(ret < 0){
		perror("read error");
		return -1;
	}else if(ret == 0){
		printf("end of file!\n");
	}
	printf("buf:[%s]\n",buf);
	//关闭文件
	close(fd);
	return 0;
}

2.文件描述符：非负整数

凭什么一个整数能够操作文件？

一个进程中会打开很多文件，那么进程就需要对这些文件进行管理（描述+组织）

描述：结构体组织：结构体数组

进程通过file结构体描述文件，并且使用结构体数组将这些描述符组织起来进行管理，我们打开文件所获取的文件描述符其实就是这个数组中对应文件描述信息的下标。我们用户通过下标找到文件描述信息，进而对文件进行操作。

文件流指针与文件描述符关系：

文件流指针这个结构体中封装了文件描述符作为成员变量。

文件缓冲区：

向文件写入数据是先写入缓冲区中，等缓冲区满了，才一次性写入文件；缓冲区在库函数的文件流指针中，系统调用中没有。

普通文件不具备换行刷新缓冲区的功能，只有标准输出文件才有这个功能

文件描述符的分配规则：

遵循最小使用原则，一个进程运行直接打开三个文件（标准输入0、标准输出1、标准错误2）

文件重定向：dup2（oldfd, newfd）

本质：改变描述符下标所对应的文件描述信息

简单的minishell的实现：

/*编写建议的minishell，实现能够运行shell的 外部命令
 * 1.读取缓冲区
 * 2.解析输入
 * 3.创建子进程
 * 4.程序替换
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>

int main()
{
    char buf[1024] ={ 0 };
    while(1){
	printf("[sun@sun~]:");
	fflush(stdout);//刷新标准输出缓冲区--将缓冲区的数据直接打印
	memset(buf, 0x00, 1024);
	//%[^\n]  scanf取数据的时候遇到各种空白字符就会停止读取
	//        为了读取所有的输入，让scanf遇到换行的时候再终止
	//%*c     scanf取数据之后，缓冲区中遗留换行符，取不出来，导致
	//        scanf非阻塞，陷入死循环，所以取出一个字符并丢弃
	//scanf返回值读取数据的个数，如果读取失败，避免缓冲区的换行取不出来
	//导致死循环（防备直接回车情况）
	if(scanf("%[^\n]%*c", buf) != 1){
	    getchar();
	    continue;
	}
	//ls -l >> a.txt
	char* str = buf;
	int redirect_flag = 0;//0-清空 1-追加
	char* redirect_file = NULL;
	    int fd = -1;
	while(*str != '\0'){
	    //如果当前字符是重定向符号，则进入判断，将整个命令从这里截断
	    //前边是命令，后边是重定向信息
	    if(*str == '>'){
		*str = '\0';
		//判断重定向方式
		redirect_flag++;
		if(*(str+1) == '>'){
		    redirect_flag++;
		}
		str += redirect_flag;
		//走完文件名前边的空白字符
		while(isspace(*str) && *str != '\0'){
		    *str++ = '\0';
		}
		//文件名的起始位置
		redirect_file = str;
		//走完文件名
		while(!isspace(*str) && *str != '\0'){
		    str++;
		}
		//文件名最后需要结束符
		*str = '\0';
		continue;
	    }
	    str++;
	}
	//ls    -l  -a
	char *ptr = buf;
	int argc = 0;
	char *argv[32];
	while(*ptr != '\0')
	{
	    if(!isspace(*ptr))
	    {
		argv[argc++] = ptr;
		//将ls读完，指向空白字符处
		while(*ptr != '\0' && !isspace(*ptr))
		{
		    ++ptr;
		}
	    }
	    //将空白字符全部替换为字符串结尾标志
	    *ptr = '\0';
	    ++ptr;
	}
	//参数结尾必须为空
	argv[argc] = NULL;
	//创建子进程
	int pid = fork();
	if(pid < 0){
	    perror("fork error");
	    return -1;
	}else if(pid == 0){
	    //子进程程序替换，运行指定命令
	    if(redirect_flag == 1){
		//清空重定向
		fd = open(redirect_file, O_CREAT|O_WRONLY|O_TRUNC, 0664);
		//这个重定向不能再父进程中完成，因为一旦父进程重定向了，
		//shell程序后续的界面就打印不出来了，都会写入到这个文件中
		dup2(fd, 1);
	    }else if(redirect_flag == 2){
		//追加重定向
		fd = open(redirect_file, O_CREAT|O_WRONLY|O_APPEND, 0664);
		dup2(fd, 1);
	    }
	    execvp(argv[0],argv);
	    exit(0);
	}
	//避免僵尸子进程
	waitpid(pid, NULL, 0);
    }
    return 0;
}

3.文件系统：管理磁盘文件（以linux下ext2为例）

文件系统下是按块分配的，一块大小是4k，其中有一个超级块（里面有文件系统的类型，块个数，块已使用数目和未使用数目）

文件如果大于4k，文件系统分配块时，不是顺序分配，是根据inode节点找到一个文件的完整信息

超级快，inode-bitmap，data-bitmap，inode，data

inode节点（大小、权限、用户、时间、文件的存储地址）（查看inode节点号：ls -i）

普通文件和目录文件有什么不同？

目录也是文件只不过数据存储的是目录下的文件名和inode节点号（最主要的），文件名和inode节点--->目录项

查看文件内容：cat file 流程：通过文件名在目录项中获取文件inode节点->通过inode节点找到数据存储位置->读取文件数据

4.软链接和硬链接

创建硬链接：ln 原文件名硬链接文件名

创建软链接：ln -s 原文件名软链接文件名

软链接和硬链接的区别：