湖北网站排名优化,360seo优化,wordpress 更改端口,wordpress 防爆破文件I/O
标准C的I/O
FILE结构体
下面只列出了5个成员 可以观察到#xff0c;有些函数没有FILE类型的结构体指针例如printf主要是一些标准输出#xff0c;因为其内部用到了stdin#xff0c;stdout#xff0c;stderr查找文件所在的位置:find \ -name stat.h查找头文件所…文件I/O
标准C的I/O
FILE结构体
下面只列出了5个成员 可以观察到有些函数没有FILE类型的结构体指针例如printf主要是一些标准输出因为其内部用到了stdinstdoutstderr查找文件所在的位置:find \ -name stat.h查找头文件所在的位置。可以使用gcc#include sys/stat.hint main() {return 0;
}gcc -M test.c代码文件
src .c的目标文件 bin 编译链接生成的可执行文件 obj 存放生成的.o的目标文件 include 存储头文件
缓冲
缓冲类型 全缓冲Fully Buffered 数据被写入缓冲区当缓冲区满或显式调用fflush时才写入目标。通常用于文件I/O尤其是磁盘文件。 行缓冲Line Buffered 数据在遇到换行符时被写入目标。通常用于终端输入输出如标准输入stdin和标准输出stdout。
#includestdio.h
#includeunistd.hint main(void)
{printf(Hello Iotak\n);while(1){sleep(1);}return 0;
}sleep函数不是标准C库的一部分而是POSIX标准的一部分 在大多数Unix-like系统如Linux和macOS上sleep函数定义在unistd.h头文件中。 在Windows上你可以使用Sleep函数注意首字母大写它定义在windows.h头文件中。 无缓冲Unbuffered 每次I/O操作直接与目标交互没有中间缓冲区。通常用于标准错误stderr。
常见的I/O函数及其缓冲特性
标准输入/输出函数 printf、puts、putchar默认行缓冲对于终端全缓冲对于文件。scanf、getchar、gets默认行缓冲对于终端全缓冲对于文件。 文件操作函数 fprintf、fputs、fputc默认全缓冲。fscanf、fgetc、fgets默认全缓冲。fread、fwrite默认全缓冲。fclose、fflush显式刷新缓冲区。setbuf、setvbuf允许手动设置缓冲方式和缓冲区大小。
特殊情况
标准错误stderr stderr默认是无缓冲的这样可以确保错误信息立即显示不会因为缓冲而延迟。使用setvbuf可以改变stderr的缓冲方式。
示例
默认缓冲行为
#include stdio.hint main() {printf(This is a test.\n); // 行缓冲遇到换行符会刷新fprintf(stderr, This is an error message.\n); // 无缓冲立即显示return 0;
}手动设置缓冲方式
#include stdio.hint main() {char buffer[1024];setvbuf(stdout, buffer, _IOFBF, sizeof(buffer)); // 设置stdout为全缓冲printf(This is a test.); // 不会立即显示因为没有换行符fflush(stdout); // 显式刷新缓冲区return 0;
}总结
标准输入/输出通常行缓冲对于终端或全缓冲对于文件。标准错误默认无缓冲。文件操作默认全缓冲。手动控制可以使用setbuf和setvbuf函数手动设置缓冲方式和缓冲区大小。
标准输入/输出函数
1. int printf(const char *format, ...); 头文件stdio.h 功能将格式化的数据写入到标准输出通常是屏幕。 参数 const char *format格式控制字符串。...可变参数列表根据格式字符串中的占位符提供相应的值。 返回值成功时返回打印的字符数失败时返回一个负值。 例子 #include stdio.h
int main() {printf(Hello, World!\n);return 0;
}2. int scanf(const char *format, ...); 头文件stdio.h 功能从标准输入读取格式化输入。 参数 const char *format格式控制字符串。...可变参数列表通常是指向变量的指针用于存储读取的值。 返回值成功时返回成功读取并赋值的数据项数量到达文件结束或遇到错误时返回EOF。 例子 #include stdio.h
int main() {int num;printf(Enter an integer: );scanf(%d, num);printf(You entered: %d\n, num);return 0;
}3. int puts(const char *s); 头文件stdio.h 功能将字符串写入标准输出自动添加换行符。 参数 const char *s要写入的字符串。 返回值成功时返回非负值如果发生错误则返回EOF。 例子 #include stdio.h
int main() {puts(Hello, World!);return 0;
}4. char *gets(char *s); 头文件stdio.h 功能从标准输入读取一行字符串不推荐使用存在缓冲区溢出风险。 参数 char *s指向存储读取字符串的缓冲区的指针。 返回值成功时返回指向字符串的指针如果到达文件末尾或发生错误则返回NULL。 例子 #include stdio.h
int main() {char buffer[100];printf(Enter a line: );gets(buffer); // 不推荐使用printf(You entered: %s\n, buffer);return 0;
}5. int getchar(void); 头文件stdio.h 功能从标准输入读取下一个可用字符。 参数无。 返回值成功时返回读取的字符如果到达文件结束或发生错误则返回EOF。 例子 #include stdio.h
int main() {int ch;printf(Press any key and then press enter: );ch getchar();printf(You pressed: %c\n, ch);return 0;
}6. int putchar(int c); 头文件stdio.h 功能将指定的字符写入到标准输出。 参数 int c要写入的字符。 返回值成功时返回写入的字符如果发生错误则返回EOF。 例子 #include stdio.h
int main() {putchar(A);return 0;
}文件操作函数
7. FILE *fopen(const char *path, const char *mode); 头文件stdio.h 功能打开或创建一个文件并返回一个指向该文件的FILE类型指针。 参数 const char *path文件路径。const char *mode打开模式如r表示只读w表示写入等。 返回值成功时返回指向文件的指针如果打开失败则返回NULL。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}fclose(file);return 0;
}8. int fclose(FILE *stream); 头文件stdio.h 功能关闭一个已打开的文件流。 参数 FILE *stream指向文件流的指针。 返回值成功时返回0如果发生错误则返回EOF。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}fclose(file);return 0;
}9. int fprintf(FILE *stream, const char *format, ...); 头文件stdio.h 功能将格式化的数据写入指定的流。 参数 FILE *stream指向文件流的指针。const char *format格式控制字符串。...可变参数列表根据格式字符串中的占位符提供相应的值。 返回值成功时返回打印的字符数失败时返回一个负值。 例子 #include stdio.h
int main() {FILE *file fopen(test.txt, w);if (file NULL) {printf(Error opening file.\n);return 1;}fprintf(file, This is a test.\n);fclose(file);return 0;
}10. int fscanf(FILE *stream, const char *format, ...); 头文件stdio.h 功能从指定的流读取格式化输入。 参数 FILE *stream指向文件流的指针。const char *format格式控制字符串。...可变参数列表通常是指向变量的指针用于存储读取的值。 返回值成功时返回成功读取并赋值的数据项数量到达文件结束或遇到错误时返回EOF。 例子 #include stdio.h
int main() {FILE *file fopen(test.txt, r);if (file NULL) {printf(Error opening file.\n);return 1;}char str[100];fscanf(file, %s, str);printf(Read from file: %s\n, str);fclose(file);return 0;
}11. char *fgets(char *str, int n, FILE *stream); 头文件stdio.h 功能从流中读取一行直到换行符或达到指定长度减一。 参数 char *str指向存储读取字符串的缓冲区的指针。int n要读取的最大字符数包括终止的空字符。FILE *stream指向文件流的指针。 返回值成功时返回指向字符串的指针如果到达文件末尾或发生错误则返回NULL。 例子 #include stdio.h
int main() {char buffer[100];FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}fgets(buffer, sizeof(buffer), file);printf(Read from file: %s, buffer);fclose(file);return 0;
}12. int fputs(const char *str, FILE *stream); 头文件stdio.h 功能向指定的流写入一个字符串不包括终止的空字符。 参数 const char *str要写入的字符串。FILE *stream指向文件流的指针。 返回值成功时返回非负值如果发生错误则返回EOF。 例子 #include stdio.h
int main() {FILE *file fopen(test.txt, w);if (file NULL) {printf(Error opening file.\n);return 1;}const char *message This is a message.;fputs(message, file);fclose(file);return 0;
}13. int fgetc(FILE *stream); 头文件stdio.h 功能从指定的流中读取下一个字符。 参数 FILE *stream指向文件流的指针。 返回值成功时返回读取的字符如果到达文件结束或发生错误则返回EOF。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}int ch;while ((ch fgetc(file)) ! EOF) {putchar(ch);}fclose(file);return 0;
}14. int fputc(int c, FILE *stream); 头文件stdio.h 功能将指定的字符写入到指定的流。 参数 int c要写入的字符。FILE *stream指向文件流的指针。 返回值成功时返回写入的字符如果发生错误则返回EOF。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, w);if (file NULL) {printf(Failed to open file.\n);return 1;}fputc(A, file);fclose(file);return 0;
}15. int fseek(FILE *stream, long offset, int whence); 头文件stdio.h 功能设置文件流的位置指针。 参数 FILE *stream指向文件流的指针。long offset相对于whence的偏移量。int whence位置基准点如SEEK_SET表示文件开头SEEK_CUR表示当前位置SEEK_END表示文件结尾。 返回值成功时返回0如果发生错误则返回非零值。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}fseek(file, 5, SEEK_SET); // 移动到文件开头后的第5个字节fclose(file);return 0;
}16. long ftell(FILE *stream); 头文件stdio.h 功能获取文件流的当前读写位置。 参数 FILE *stream指向文件流的指针。 返回值成功时返回当前的位置以字节为单位如果发生错误则返回-1L。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}fseek(file, 5, SEEK_SET); // 移动到文件开头后的第5个字节long pos ftell(file);printf(Current position: %ld\n, pos);fclose(file);return 0;
}17. void rewind(FILE *stream); 头文件stdio.h 功能将文件流的位置指针重置到文件开头。 参数 FILE *stream指向文件流的指针。 返回值无。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}fseek(file, 5, SEEK_SET); // 移动到文件开头后的第5个字节rewind(file); // 重置到文件开头fclose(file);return 0;
}18. int feof(FILE *stream); 头文件stdio.h 功能检测文件流是否到达文件结束。 参数 FILE *stream指向文件流的指针。 返回值如果文件流到达文件结束则返回非零值否则返回0。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}int ch;while ((ch fgetc(file)) ! EOF) {putchar(ch);}if (feof(file)) {printf(End of file reached.\n);}fclose(file);return 0;
}19. int ferror(FILE *stream); 头文件stdio.h 功能检测文件流是否发生错误。 参数 FILE *stream指向文件流的指针。 返回值如果文件流发生错误则返回非零值否则返回0。 例子 #include stdio.h
int main() {FILE *file fopen(nonexistent.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}int ch;while ((ch fgetc(file)) ! EOF) {if (ferror(file)) {printf(Error reading file.\n);break;}putchar(ch);}fclose(file);return 0;
}20. void clearerr(FILE *stream); 头文件stdio.h 功能清除文件流的错误标志和文件结束标志。 参数 FILE *stream指向文件流的指针。 返回值无。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, r);if (file NULL) {printf(Failed to open file.\n);return 1;}int ch;while ((ch fgetc(file)) ! EOF) {if (ferror(file)) {clearerr(file); // 清除错误标志printf(Error cleared.\n);break;}putchar(ch);}fclose(file);return 0;
}21. int remove(const char *filename); 头文件stdio.h 功能删除指定的文件。 参数 const char *filename要删除的文件名。 返回值成功时返回0如果发生错误则返回非零值。 例子 #include stdio.h
int main() {if (remove(example.txt) 0) {printf(File deleted successfully.\n);} else {printf(Error deleting file.\n);}return 0;
}22. int rename(const char *oldname, const char *newname); 头文件stdio.h 功能重命名文件。 参数 const char *oldname旧文件名。const char *newname新文件名。 返回值成功时返回0如果发生错误则返回非零值。 例子 #include stdio.h
int main() {if (rename(oldname.txt, newname.txt) 0) {printf(File renamed successfully.\n);} else {printf(Error renaming file.\n);}return 0;
}23. void setbuf(FILE *stream, char *buf); 头文件stdio.h 功能设置或取消文件流的缓冲区。 参数 FILE *stream指向文件流的指针。char *buf缓冲区指针。如果为NULL则取消缓冲。 返回值无。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, w);if (file NULL) {printf(Failed to open file.\n);return 1;}setbuf(file, NULL); // 取消缓冲fprintf(file, This is a test.\n);fclose(file);return 0;
}24. int setvbuf(FILE *stream, char *buf, int mode, size_t size); 头文件stdio.h 功能设置文件流的缓冲方式和大小。 参数 FILE *stream指向文件流的指针。char *buf缓冲区指针。如果为NULL则使用系统分配的缓冲区。int mode缓冲方式如_IOFBF表示完全缓冲_IOLBF表示行缓冲_IONBF表示不缓冲。size_t size缓冲区大小。 返回值成功时返回0如果发生错误则返回非零值。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, w);if (file NULL) {printf(Failed to open file.\n);return 1;}char buffer[1024];setvbuf(file, buffer, _IOFBF, sizeof(buffer)); // 设置完全缓冲fprintf(file, This is a test.\n);fclose(file);return 0;
}25. int fflush(FILE *stream); 头文件stdio.h 功能刷新文件流的缓冲区。 参数 FILE *stream指向文件流的指针。如果为NULL则刷新所有输出流。 返回值成功时返回0如果发生错误则返回EOF。 例子 #include stdio.h
int main() {FILE *file fopen(example.txt, w);if (file NULL) {printf(Failed to open file.\n);return 1;}fprintf(file, This is a test.\n);fflush(file); // 刷新缓冲区fclose(file);return 0;
}这些函数是标准C语言中最常用的一些I/O函数涵盖了标准输入/输出和文件操作的基本需求。希望这些信息对你有帮助如果有任何其他问题或需要进一步的解释请告诉我。
文件描述符
标准IO函数通过FILE类型的结构体指针系统IO函数则是通过文件描述符来完成
文件描述符和文件结构体指针相互的转换 fdopen将文件描述符转换为文件流方便使用标准I/O函数进行操作。fileno将文件流转换为文件描述符方便使用低级I/O系统调用进行操作。
fdopen 函数
函数原型
FILE *fdopen(int fd, const char *mode);参数说明 int fd文件描述符。 const char *mode打开模式如r表示只读w表示写入a表示追加等。 所在头文件 stdio.h 返回值 成功时返回指向文件流的指针。 失败时返回NULL。 简单示例
#include stdio.h
#include unistd.h
#include fcntl.hint main() {int fd open(example.txt, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);if (fd -1) {perror(open);return 1;}FILE *fp fdopen(fd, r);if (fp NULL) {perror(fdopen);close(fd);return 1;}// 使用文件流进行操作const char *message Hello, fdopen!;fwrite(message, 1, strlen(message), fp);// 重置文件位置指针rewind(fp);char buffer[100];size_t bytesRead fread(buffer, 1, sizeof(buffer) - 1, fp);buffer[bytesRead] \0;printf(Read from file: %s\n, buffer);fclose(fp); // 关闭文件流同时关闭文件描述符return 0;
}fileno 函数
函数原型
int fileno(FILE *stream);参数说明 FILE *stream指向文件流的指针。 所在头文件 stdio.h 返回值 成功时返回文件描述符。 失败时返回-1。 简单示例
#include stdio.h
#include unistd.hint main() {FILE *fp fopen(example.txt, r);if (fp NULL) {perror(fopen);return 1;}int fd fileno(fp);if (fd -1) {perror(fileno);fclose(fp);return 1;}printf(File descriptor: %d\n, fd);// 使用文件描述符进行操作const char *message Hello, fileno!;write(fd, message, strlen(message));// 重置文件位置指针lseek(fd, 0, SEEK_SET);char buffer[100];ssize_t bytesRead read(fd, buffer, sizeof(buffer) - 1);buffer[bytesRead] \0;printf(Read from file: %s\n, buffer);fclose(fp); // 关闭文件流同时关闭文件描述符return 0;
}文件I/O的系统调用
文件操作函数的头文件一般都需要加上unistd.h 标准输入/输出函数
1. ssize_t read(int fd, void *buf, size_t count); 头文件unistd.h 功能从文件描述符fd读取最多count个字节到缓冲区buf。 参数 int fd文件描述符。void *buf指向存储读取数据的缓冲区的指针。size_t count要读取的最大字节数。 返回值成功时返回实际读取的字节数到达文件结束时返回0发生错误时返回-1。 例子 #include unistd.h
#include stdio.hint main() {char buffer[100];ssize_t bytesRead read(STDIN_FILENO, buffer, sizeof(buffer) - 1);if (bytesRead -1) {perror(read);return 1;}buffer[bytesRead] \0; // 确保字符串以空字符结尾printf(Read from stdin: %s\n, buffer);return 0;
}2. ssize_t write(int fd, const void *buf, size_t count); 头文件unistd.h 功能将buf中的count个字节写入文件描述符fd。 参数 int fd文件描述符。const void *buf指向要写入的数据的缓冲区的指针。size_t count要写入的字节数。 返回值成功时返回实际写入的字节数发生错误时返回-1。 例子 #include unistd.h
#include stdio.hint main() {const char *message Hello, World!\n;ssize_t bytesWritten write(STDOUT_FILENO, message, strlen(message));if (bytesWritten -1) {perror(write);return 1;}return 0;
}复制案例 io.h#ifndef __IO_H__
#define __IO_H__
extern void copy(int fdin,int fdout);
#endifio.c#includeio.h
#includeerrno.h
#includefcntl.h
#includeunistd.h
#includestdio.h
#includestring.h
#includestdlib.h#define BUFFER_LEN 1024void copy(int fdin,int fdout)
{char buffer[BUFFER_LEN];ssize_t size;while((sizeread(fdin,buffer,BUFFER_LEN))0){if(size0){fprintf(stderr,read error:%s\n,strerror(errno));exit(1);}else{if(write(fdout,buffer,size)!size){fprintf(stderr,read error:%s\n,strerror(errno));exit(1);}}}gcc obj/io -Iinclude -c src/io.c
-Iinclude --c - 产生目标文件
gcc bin/cp -Iinclude obj/io.o src/cp.c或者gcc bin/cp -Iinclude src/io.c src/cp.c
cp.c#includestdio.h
#includestring.h
#includestdlib.h
#includefcntl.h
#includeunistd.h
#includeerrno.h
#includeio.h
int main(int argc,char ** argv)
{if(argc3){fprintf(stderr,usage:%s srcfile destfile \n,argv[0]);exit(1);}int fdin open(argv[1],O_RDONLY);if(fdin0){fprintf(stderr,%s fdin open fails:%s \n,argv[1],strerror(errno));exit(1);}else{printf(%s %d\n,argv[1],fdin);}int fdout open(argv[2],O_WRONLY|O_CREAT|O_TRUNC,0777);if(fdout0){fprintf(stderr,%s fdout open fails:%s \n,argv[2],strerror(errno));exit(1);}else{printf(%s %d\n,argv[2],fdout);}copy(fdin,fdout);close(fdin);close(fdout);return 0;
}文件操作函数
C库函数的头文件都在\usr\include下-查找头文件所在的位置。可以使用gcc#include sys/stat.hint main() {return 0;
}gcc -M test.c3. int open(const char *pathname, int flags, mode_t mode); 头文件fcntl.h 和 sys/stat.h 功能打开或创建一个文件并返回一个文件描述符。 参数 const char *pathname文件路径。int flags打开模式如O_RDONLY表示只读O_WRONLY表示只写O_RDWR表示读写等在头文件fcntl.h中定义。 //例如创建一个用户可读可写的文件
int fd open(example.txt, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);mode_t mode文件权限仅在创建文件时使用。 mode参数是一个mode_t类型的值通常由几个权限位按位或|组合而成。以下是一些常用的权限位及其说明 用户权限 S_IRUSR用户读权限0400S_IWUSR用户写权限0200S_IXUSR用户执行权限0100 组权限 - S_IRGRP组读权限0040 - S_IWGRP组写权限0020 - S_IXGRP组执行权限0010 其他用户权限 S_IROTH其他用户读权限0004S_IWOTH其他用户写权限0002S_IXOTH其他用户执行权限0001 权限组合 你可以通过按位或运算|组合多个权限位来设置文件的权限。例如 用户可读可写组和其他用户不可访问 mode_t mode S_IRUSR | S_IWUSR;用户可读可写可执行组可读可执行其他用户可读 mode_t mode S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH;以下是一些常见的权限组合示例 用户可读可写 int fd open(example.txt, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);用户可读可写可执行 int fd open(example.txt, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IXUSR);用户可读可写组可读其他用户不可访问 int fd open(example.txt, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP);用户可读可写可执行组可读可写其他用户可读 int fd open(example.txt, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IROTH);八进制表示法 - 权限也可以用八进制数字表示每个数字对应一组权限 - 第一个数字用户权限 - 第二个数字组权限 - 第三个数字其他用户权限 例如- 0600用户可读可写组和其他用户不可访问- 0755用户可读可写可执行组可读可执行其他用户可读可执行- 0644用户可读可写组和其他用户可读- 使用八进制表示法设置权限int fd open(example.txt, O_CREAT | O_RDWR, 0600);返回值成功时返回文件描述符如果打开失败则返回-1。 例子 #include fcntl.h
#include sys/stat.h
#include unistd.h
#include stdio.hint main() {int fd open(example.txt, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);if (fd -1) {perror(open);return 1;}close(fd);return 0;
}creat creat函数是Linux系统中用于创建文件的一个简化版本的open函数。creat函数的主要特点是它总是创建一个新的文件并且只以写模式打开文件。如果文件已经存在creat会截断文件并覆盖其内容。
函数原型
#include fcntl.h
int creat(const char *pathname, mode_t mode);参数说明 const char *pathname要创建的文件的路径。 mode_t mode文件的权限模式。 返回值 成功时返回文件描述符非负整数。 失败时返回-1并设置errno以指示错误类型。 常用的权限模式 权限模式可以用mode_t类型的值表示通常由几个权限位按位或|组合而成。以下是一些常用的权限位 S_IRUSR用户读权限0400S_IWUSR用户写权限0200S_IXUSR用户执行权限0100S_IRGRP组读权限0040S_IWGRP组写权限0020S_IXGRP组执行权限0010S_IROTH其他用户读权限0004S_IWOTH其他用户写权限0002S_IXOTH其他用户执行权限0001 示例 #include fcntl.h
#include unistd.h
#include stdio.h
#include stdlib.h
#include string.h
#include errno.hint main() {int fd;const char *filename example.txt;const char *message Hello, creat!;char buffer[100];// 创建文件权限为用户可读可写fd creat(filename, S_IRUSR | S_IWUSR);if (fd -1) {perror(creat);exit(EXIT_FAILURE);}// 写入数据ssize_t bytesWritten write(fd, message, strlen(message));if (bytesWritten -1) {perror(write);close(fd);exit(EXIT_FAILURE);}// 重置文件位置指针lseek(fd, 0, SEEK_SET);// 读取数据ssize_t bytesRead read(fd, buffer, sizeof(buffer) - 1);if (bytesRead -1) {perror(read);close(fd);exit(EXIT_FAILURE);}buffer[bytesRead] \0; // 确保字符串以空字符结尾printf(Read from file: %s\n, buffer);// 关闭文件close(fd);return 0;
}4. int close(int fd); 头文件unistd.h 功能关闭一个已打开的文件描述符。 参数 int fd文件描述符。 返回值成功时返回0如果发生错误则返回-1。
5. off_t lseek(int fd, off_t offset, int whence); 可以计算文件的大小 printf(%s file length:%ld\n,argv[1],lseek(fdin,0L,SEEK_END));头文件unistd.h 功能设置文件描述符fd的读写位置。 参数 int fd文件描述符。off_t offset相对于whence的偏移量。如 long 或 long longint whence位置基准点如SEEK_SET表示文件开头SEEK_CUR表示当前位置SEEK_END表示文件结尾。 返回值成功时返回新的文件位置如果发生错误则返回-1。 例子 #include fcntl.h
#include sys/stat.h
#include unistd.h
#include stdio.hint main() {int fd open(example.txt, O_RDWR);if (fd -1) {perror(open);return 1;}off_t new_pos lseek(fd, 5, SEEK_SET); // 移动到文件开头后的第5个字节if (new_pos -1) {perror(lseek);close(fd);return 1;}close(fd);return 0;
}生成空洞文件
#includestdio.h
#includestdlib.h
#includestring.h
#includefcntl.h
#includeunistd.hchar *buffer 0123456789;int main(int argc,char *argv[])
{if(argc2){fprintf(stderr,parameter is less\n);exit(0);}int fd open(argv[1],O_CREAT|O_RDWR,0777);if(fd-1) // 文件打开s失败{fprintf(stderr,%s file open fail\n,argv[1]);exit(1);}lseek(fd,20L,SEEK_SET);if(write(fd,buffer,strlen(buffer)*sizeof(char))-1){fprintf(stderr,write error %s\n,argv[1]);exit(1);}return 0;
}查看文件的ASCALL码 od -c hole 查看文件磁盘块大小 sudo tune2fs -l /dev/sda1我们每次一次io读写文件读写的基本单位是一个磁盘块一个磁盘块的大小是4096个字节。所以缓存大小设置为磁盘块的大小
6. int dup(int oldfd); - **是将oldfd的文件描述符表的指针复制给newfd,使oldfd和newfd都指向oldfd的文件描述符表的指针** 头文件unistd.h 功能复制一个文件描述符。 参数 int oldfd要复制的文件描述符。 返回值成功时返回新的文件描述符如果发生错误则返回-1。 例子 #include unistd.h
#include stdio.hint main() {int fd open(example.txt, O_RDWR);if (fd -1) {perror(open);return 1;}int new_fd dup(fd);if (new_fd -1) {perror(dup);close(fd);return 1;}close(fd);close(new_fd);return 0;
}实现cat命令
#includeio.h
#includestdio.h
#includestdlib.h
#includestring.h
#includeunistd.h
#includefcntl.hint main(int argc, char *argv[])
{int fd_in STDIN_FILENO;int fd_out STDOUT_FILENO;for(int i1;iargc;i) // 这里是为了实现输入 cat file.txt 的情况{fd_in open(argv[i],O_RDONLY);if(fd_in0){perror(open error);continue;}copy(fd_in,fd_out);close(fd_in);}if(argc1) // 这里实现的是只是输入 cat命令时的情况copy(fd_in,fd_out);return 0;
}实现±重定向 mcat file.txt // 将file.txt输出到屏幕中这要求将file.txt以只读方式打开之后将其文件描述符表的指针复制给标准输入 mcat - file.txt //将屏幕输入的内容输出到file.txt中这要求以可读方式打开file.txt之后将其文件描述符表指针复制给标准输出 #includestdio.h
#includestdlib.h
#includeunistd.h
#includefcntl.h
#includestring.h
#includeio.h
/*bin/mcat file 为输入从定向bin/mcat - file - 为输出重定向
*/int main(int argc,char *argv[])
{int fd_in,fd_out;int flag 0;for(int i 1;iargc;i){if(!strcmp(,argv[i])){fd_in open(argv[i],O_RDONLY);if(fd_in0){perror(poen error);exit(1);}// 将标准输入重定向到文件if(dup2(fd_in,STDIN_FILENO)!STDIN_FILENO){perror(dup2 error);exit(1);}close(fd_in);}else if(!strcmp(-,argv[i])){// 将文件的内容不是输出到屏幕而是输出到一个文件中fd_out open(argv[i],O_WRONLY|O_CREAT|O_TRUNC,0777);if(fd_out0){perror(open error);exit(1);}if(dup2(fd_out,STDOUT_FILENO)!STDOUT_FILENO){perror(dup2 error);exit(1);}close(fd_out);}else{flag 1;fd_in open(argv[i],O_RDONLY);if(fd_in0){perror(open error);exit(1);}if(dup2(fd_in,STDIN_FILENO)){perror(dup2 error);exit(1);}copy(STDIN_FILENO,STDOUT_FILENO);close(fd_in);}}if(!flag)copy(STDIN_FILENO,STDOUT_FILENO);return 0;
}文件描述符的复制
7. int dup2(int oldfd, int newfd); 头文件unistd.h 功能复制一个文件描述符并将其绑定到另一个文件描述符。 参数 int oldfd要复制的文件描述符。int newfd新的文件描述符。 返回值成功时返回新的文件描述符如果发生错误则返回-1。 例子 #include unistd.h
#include stdio.hint main() {int fd open(example.txt, O_RDWR);if (fd -1) {perror(open);return 1;}int new_fd dup2(fd, 3); // 将fd复制到文件描述符3if (new_fd -1) {perror(dup2);close(fd);return 1;}close(fd);close(new_fd);return 0;
}文件操作的内核数据结构 int fcntl(int fd, int cmd, … /* arg */ ); fcntl 函数是 Unix 和类 Unix 操作系统中用于文件描述符控制的多功能函数。它可以执行多种与文件描述符相关的操作如复制文件描述符、获取和设置文件状态标志、获取和设置文件锁等。
#include fcntl.hint fcntl(int fd, int cmd, ... /* arg */ );fd文件描述符表示要操作的文件或 I/O 对象。 cmd命令指定要执行的操作。常见的命令包括 F_DUPFD复制文件描述符。F_GETFD获取文件描述符的标志。F_SETFD设置文件描述符的标志。F_GETFL获取文件状态标志。F_SETFL设置文件状态标志。F_GETLK获取文件锁。F_SETLK设置文件锁。F_SETLKW设置文件锁等待锁释放。 arg根据 cmd 的不同第三个参数可能是整数、指向 struct flock 的指针或其他类型的参数。 复制文件描述符
#include fcntl.h
#include stdio.h
#include unistd.hint main() {int old_fd 0; // 标准输入文件描述符int new_fd;// 复制文件描述符new_fd fcntl(old_fd, F_DUPFD, 100); // 从100开始寻找最小的未使用的文件描述符if (new_fd -1) {perror(fcntl F_DUPFD);return 1;}printf(Old FD: %d, New FD: %d\n, old_fd, new_fd);// 关闭新旧文件描述符close(old_fd);close(new_fd);return 0;
}获取和设置文件描述符标志
#include fcntl.h
#include stdio.h
#include unistd.hint main() {int fd Ⅰ; // 标准输入文件描述符int flags;// 获取文件描述符标志flags fcntl(fd, F_GETFD);if (flags -1) {perror(fcntl F_GETFD);return 1;}printf(Current flags: %d\n, flags);// 设置文件描述符标志if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) -1) {perror(fcntl F_SETFD);return 1;}// 再次获取文件描述符标志flags fcntl(fd, F_GETFD);if (flags -1) {perror(fcntl F_GETFD);return 1;}printf(New flags: %d\n, flags);return 0;
}获取和设置文件状态标志
#include fcntl.h
#include stdio.h
#include unistd.hint main() {int fd Ⅰ; // 标准输入文件描述符int flags;// 获取文件状态标志flags fcntl(fd, F_GETFL);if (flags -1) {perror(fcntl F_GETFL);return 1;}printf(Current file status flags: %d\n, flags);// 设置文件状态标志if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) -1) {perror(fcntl F_SETFL);return 1;}// 再次获取文件状态标志flags fcntl(fd, F_GETFL);if (flags -1) {perror(fcntl F_GETFL);return 1;}printf(New file status flags: %d\n, flags);return 0;
}文件锁
#include fcntl.h
#include stdio.h
#include unistd.h
#include sys/file.hint main() {int fd;struct flock lock;// 打开文件fd open(example.txt, O_RDWR | O_CREAT, 06½);if (fd -1) {perror(open);return 1;}// 初始化文件锁结构lock.l_type F_WRLCK; // 写锁lock.l_whence SEEK_SET;lock.l_start 0;lock.l_len 0; // 整个文件lock.l_pid getpid();// 设置文件锁if (fcntl(fd, F_SETLK, lock) -1) {perror(fcntl F_SETLK);close(fd);return 1;}// 释放文件锁lock.l_type F_UNLCK;if (fcntl(fd, F_SETLK, lock) -1) {perror(fcntl F_SETLK);close(fd);return 1;}// 关闭文件close(fd);return 0;
}总结
fcntl 函数是一个非常强大的工具可以用于多种文件描述符相关的操作。以下是一些常见的操作
复制文件描述符F_DUPFD获取和设置文件描述符标志F_GETFD 和 F_SETFD获取和设置文件状态标志F_GETFL 和 F_SETFL文件锁F_GETLK、F_SETLK 和 F_SETLKW
设置文件标准标志
void set_fl(int fd,int flag)
{int val fcntl(fd,F_GETFL);// 获取原来的文件状态n标志val|flag; // 增加新的文件状态标志if(fcntl(fd,F_SETFL,val)0)fprintf(stderr,fcntl error %s\n,strerror(errno));
}void clr_fl(int fd,int flag)
{int val fcntl(fd,F_GETFL);// 清除指定的文件状态标志val~flag;if(fcntl(fd,F_SETFL,val)0)fprintf(stderr,fcntl error %s,strerror(errno));}文件描述符标志和文件状态标志的区别
在 fcntl 函数中文件描述符标志File Descriptor Flags和文件状态标志File Status Flags是两种不同类型的状态标志它们各自有不同的用途和意义。
文件描述符标志File Descriptor Flags
文件描述符标志是与特定文件描述符相关联的标志而不是与文件本身相关联的标志。这些标志通常影响文件描述符的行为特别是在进程执行 exec 系列函数时。
常见的文件描述符标志
FD_CLOEXEC这是一个非常重要的标志。当设置此标志时文件描述符将在执行 exec 系列函数时自动关闭。如果没有设置此标志文件描述符将保持打开状态。
设置和获取文件描述符标志 获取文件描述符标志 int flags fcntl(fd, F_GETFD);
if (flags -1) {perror(fcntl F_GETFD);return 1;
}设置文件描述符标志 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) -1) {perror(fcntl F_SETFD);return 1;
}文件状态标志File Status Flags
文件状态标志是与文件本身相关联的标志它们影响文件的打开方式和 I/O 操作的行为。这些标志通常在打开文件时通过 open 函数的 flags 参数设置也可以在文件打开后通过 fcntl 函数修改。
常见的文件状态标志
O_RDONLY只读模式。O_WRONLY只写模式。O_RDWR读写模式。O_APPEND每次写操作都追加到文件末尾。O_NONBLOCK非阻塞模式。O_SYNC同步写操作确保数据立即写入磁盘。O_CREAT如果文件不存在则创建文件。O_TRUNC如果文件已存在且为只写或读写模式则截断文件长度为0。O_EXCL与 O_CREAT 一起使用如果文件已存在则打开失败。
设置和获取文件状态标志 获取文件状态标志 int flags fcntl(fd, F_GETFL);
if (flags -1) {perror(fcntl F_GETFL);return 1;
}设置文件状态标志 if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) -1) {perror(fcntl F_SETFL);return 1;
}主要区别 作用对象 文件描述符标志作用于特定的文件描述符影响文件描述符的行为。文件状态标志作用于文件本身影响文件的打开方式和 I/O 操作的行为。 使用场景 文件描述符标志主要用于控制文件描述符在 exec 系列函数执行时的行为。文件状态标志主要用于控制文件的打开方式和 I/O 操作的行为。 标志位 文件描述符标志主要标志是 FD_CLOEXEC。文件状态标志包括 O_RDONLY、O_WRONLY、O_RDWR、O_APPEND、O_NONBLOCK、O_SYNC 等。
示例
以下是一个示例展示了如何分别获取和设置文件描述符标志和文件状态标志
#include fcntl.h
#include stdio.h
#include unistd.h
#include errno.hint main() {int fd;int fd_flags, fl_flags;// 打开文件fd open(example.txt, O_RDWR | O_CREAT, 0644);if (fd -1) {perror(open);return 1;}// 获取文件描述符标志fd_flags fcntl(fd, F_GETFD);if (fd_flags -1) {perror(fcntl F_GETFD);close(fd);return 1;}printf(Current FD flags: %d\n, fd_flags);// 设置文件描述符标志if (fcntl(fd, F_SETFD, fd_flags | FD_CLOEXEC) -1) {perror(fcntl F_SETFD);close(fd);return 1;}printf(New FD flags: %d\n, fcntl(fd, F_GETFD));// 获取文件状态标志fl_flags fcntl(fd, F_GETFL);if (fl_flags -1) {perror(fcntl F_GETFL);close(fd);return 1;}printf(Current file status flags: %d\n, fl_flags);// 设置文件状态标志if (fcntl(fd, F_SETFL, fl_flags | O_NONBLOCK) -1) {perror(fcntl F_SETFL);close(fd);return 1;}printf(New file status flags: %d\n, fcntl(fd, F_GETFL));// 关闭文件close(fd);return 0;
}总结
文件描述符标志与特定文件描述符相关联影响文件描述符的行为特别是 exec 时的行为。文件状态标志与文件本身相关联影响文件的打开方式和 I/O 操作的行为。
希望这些信息对你有帮助如果你有任何其他问题或需要进一步的解释请告诉我。
文件的原子操作
I/O处理模型 非阻塞IO 设置阻塞方式睡眠之后会等待输入 #includestdio.h
#includefcntl.h
#includeunistd.h
#includestring.h
#includestdlib.hint main()
{char buffer[4096] {\0};ssize_t size 0;sleep(5);size read(STDIN_FILENO,buffer,sizeof(buffer)); // 默认是阻塞的if(size0){perror(read error);exit(1);}else if(size0){printf(read finished!\n);}else{if(write(STDOUT_FILENO,buffer,size)!size)perror(write error);}return 0;
}当设置为阻塞方式时没有输入内容会报错 int main()
{char buffer[4096] {\0};ssize_t size 0;set_fl(STDIN_FILENO,O_NONBLOCK);sleep(5);size read(STDIN_FILENO,buffer,sizeof(buffer));// 设置非阻塞if(size0){perror(read error);exit(1);}else if(size0){printf(read finished!\n);}else{if(write(STDOUT_FILENO,buffer,size)!size)perror(write error);}return 0;
}文件锁机制
存储映射
--------------------
文件操作函数
文件共享机制
