目录
fopen, fwrite, fread, 和 fseek 函数来操作文件
例子21 使用 fwrite 和 fread 函数来写入和读取文件内容大小
例子23 使用 fwrite 和 fread 写入读取结构体到文件
例子1 打开文件，并输出是否成功
#include <sys/types.h> // 包含系统调用所需的基本数据类型
#include <sys/stat.h> // 包含获取和设置文件属性的功能
#include <fcntl.h> // 包含文件控制选项，如文件打开函数
#include <stdio.h> // 包含标准输入输出函数，如printf
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
// 尝试以读写模式打开当前目录下的file1文件，将返回的文件描述符赋值给fd
fd = open("./file1",O_RDWR);
// 输出文件描述符的值，如果文件打开成功，显示文件描述符；如果失败，显示-1
printf("fd = %d\n",fd);
return 0; // 程序正常结束，返回0
}
例子2 打开文件，不存在则创建
#include <sys/types.h> // 包含定义数据类型的系统调用
#include <sys/stat.h> // 包含定义文件状态的标志
#include <fcntl.h> // 包含文件控制函数，例如open
#include <stdio.h> // 包含标准输入输出函数，例如printf
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
// 尝试以读写模式打开当前目录下的file1文件
fd = open("./file1", O_RDWR);
if(fd == -1){ // 检查文件是否成功打开，如果返回-1表示打开失败
printf("open file1 failed\n"); // 打印错误信息
// 如果文件打开失败，则尝试创建文件，赋予读写权限
fd = open("./file1", O_RDWR | O_CREAT, 0600);
if(fd > 0){ // 再次检查文件描述符，如果成功创建，则fd应该大于0
printf("create file1 success!\n"); // 打印文件创建成功的信息
}
}
return 0; // 程序正常结束
}
例子3 创建一个文件，如果文件已存在，则会失败
#include <sys/types.h> // 包含定义数据类型的系统调用
#include <sys/stat.h> // 包含定义文件状态的标志
#include <fcntl.h> // 包含文件控制定义，如文件访问模式
#include <stdio.h> // 包含标准输入输出库，例如printf函数
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
// 尝试以读写模式创建一个新文件"./file1"，如果该文件已存在，则不创建并返回-1
fd = open("./file1", O_RDWR | O_CREAT | O_EXCL, 0600);
if(fd == -1){ // 检查open函数的返回值，如果是-1，则说明文件已经存在或者有其他错误
printf("file cunZai\n"); // 输出文件已存在的信息
}
return 0; // 程序正常结束，返回0
}
例子4 打开文件，写入文本，读取文本并打印出来
#include <sys/types.h> // 包含定义数据类型的系统调用
#include <sys/stat.h> // 包含定义文件状态的标志
#include <fcntl.h> // 包含文件控制定义，如文件访问模式
#include <stdio.h> // 包含标准输入输出库，例如printf函数
#include <unistd.h> // 包含各种常用的系统调用，如read, write, close
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含内存分配函数，如malloc和free
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
char *buf = "helloworld!"; // 定义一个字符串常量
fd = open("./file1", O_RDWR); // 尝试以读写模式打开文件file1
if(fd == -1){ // 检查文件是否成功打开
printf("open file1 failed\n"); // 打开失败，打印错误消息
fd = open("./file1", O_RDWR|O_CREAT, 0600); // 尝试创建文件
if(fd > 0){ // 检查文件是否成功创建
printf("create file1 success!\n"); // 创建成功，打印成功消息
}
}
printf("open success : fd = %d\n", fd); // 打印文件描述符，确认文件已打开
int n_write = write(fd, buf, strlen(buf)); // 向文件写入字符串buf
if(n_write != -1){ // 检查写入是否成功
printf("write %d byte to file\n", n_write); // 打印写入的字节数
}
char *readBuf; // 定义一个字符指针用于读取数据
readBuf = (char *)malloc(sizeof(char) * n_write + 1); // 为读取的数据分配内存
int n_read = read(fd, readBuf, n_write); // 从文件中读取数据
readBuf[n_read] = '\0'; // 确保字符串正确终止
printf("read %d bytes, content: %s\n", n_read, readBuf); // 打印读取的字节数和内容
close(fd); // 关闭文件
return 0; // 程序结束
}
例子5 打开、写入、再次打开、读取和关闭操作
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、read、write、close
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc和free
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
char *buf = "helloworld!"; // 定义字符串常量buf，用于写入文件
// 尝试以读写模式打开文件file1
fd = open("./file1", O_RDWR);
if(fd == -1){ // 如果文件打开失败（fd为-1）
printf("open file1 failed\n"); // 输出错误信息
// 以读写模式创建文件file1，文件权限为0600（仅所有者有读写权限）
fd = open("./file1", O_RDWR|O_CREAT, 0600);
if(fd > 0){ // 如果文件创建成功（fd大于0）
printf("create file1 success!\n"); // 输出创建成功信息
}
}
printf("open success : fd = %d\n", fd); // 输出成功打开文件的文件描述符
// 向文件写入字符串buf的内容
int n_write = write(fd, buf, strlen(buf));
if(n_write != -1){ // 如果写入成功（n_write不为-1）
printf("write %d bytes to file\n", n_write); // 输出写入的字节数
}
close(fd); // 关闭文件
// 再次以读写模式打开文件file1
fd = open("./file1", O_RDWR);
char *readBuf; // 定义字符指针readBuf，用于存储读取的数据
readBuf = (char *)malloc(sizeof(char) * n_write + 1); // 为读取的数据分配内存
// 从文件中读取100字节的数据到readBuf
int n_read = read(fd, readBuf, 100);
readBuf[n_read] = '\0'; // 确保字符串以null字符结束
printf("read %d bytes, content: %s\n", n_read, readBuf); // 输出读取的字节数和内容
close(fd); // 关闭文件
return 0; // 程序正常结束
}
例子6 打开、写入、文件指针、读取和关闭操作
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、read、write、close，以及lseek
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc和free
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
char *buf = "helloworld!"; // 定义字符串常量buf，用于写入文件
// 尝试以读写模式打开文件file1
fd = open("./file1", O_RDWR);
if(fd == -1){ // 如果文件打开失败（fd为-1）
printf("open file1 failed\n"); // 输出错误信息
// 以读写模式创建文件file1，文件权限为0600（仅所有者有读写权限）
fd = open("./file1", O_RDWR|O_CREAT, 0600);
if(fd > 0){ // 如果文件创建成功（fd大于0）
printf("create file1 success!\n"); // 输出创建成功信息
}
}
printf("open success : fd = %d\n", fd); // 输出成功打开文件的文件描述符
// 向文件写入字符串buf的内容
int n_write = write(fd, buf, strlen(buf));
if(n_write != -1){ // 如果写入成功（n_write不为-1）
printf("write %d bytes to file\n", n_write); // 输出写入的字节数
}
// 分配内存以准备读取文件
char *readBuf;
readBuf = (char *)malloc(sizeof(char) * n_write + 1);
// 使用lseek移动文件指针，偏移量为-21，即从当前位置（写入结束的地方）向前移动21个字节
lseek(fd, -21, SEEK_CUR);
// 从当前文件指针的位置（移动后）开始读取100字节数据到readBuf
int n_read = read(fd, readBuf, 100);
readBuf[n_read] = '\0'; // 确保字符串以null字符结束
printf("read %d bytes, content: %s\n", n_read, readBuf); // 输出读取的字节数和内容
close(fd); // 关闭文件
return 0; // 程序正常结束
}
例子7 使用 lseek 函数获取该文件的大小
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close，以及lseek
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc和free
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
char *buf = "helloworld!"; // 定义字符串常量buf，此处未使用
// 尝试以读写模式打开文件file1
fd = open("./file1", O_RDWR);
if (fd == -1) { // 检查文件是否成功打开
printf("Unable to open file\n"); // 若文件打开失败，输出错误信息
return 1; // 返回错误码1
}
// 使用lseek将文件指针移动到文件末尾，返回值是文件指针的位置，即文件的大小
int filesize = lseek(fd, 0, SEEK_END);
printf("file's size is: %d bytes\n", filesize); // 输出文件大小
close(fd); // 关闭文件描述符，释放资源
return 0; // 程序正常结束
}
例子8 将一段文本追加到文件末尾
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close，以及write
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc和free
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
char *buf = "helloworld!"; // 定义字符串常量buf，用于追加到文件
// 尝试以读写模式打开文件file1，并设置O_APPEND标志，确保写入的数据总是追加到文件末尾
fd = open("./file1", O_RDWR | O_APPEND);
if(fd == -1) { // 检查文件是否成功打开
printf("Unable to open file\n"); // 若文件打开失败，输出错误信息
return 1; // 返回错误码1
}
printf("open success : fd = %d\n", fd); // 打印成功打开文件的文件描述符
// 尝试将buf中的字符串写入打开的文件
int n_write = write(fd, buf, strlen(buf));
if(n_write != -1) { // 检查写入是否成功
printf("write %d bytes to file\n", n_write); // 输出写入的字节数
} else {
printf("Failed to write to file\n"); // 若写入失败，输出错误信息
}
close(fd); // 关闭文件描述符，释放资源
return 0; // 程序正常结束
}
例子9 写入指定的字符串
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close，以及write
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc和free
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
char *buf = "helloworld!"; // 定义要写入的字符串常量
// 尝试以读写模式打开文件file1
fd = open("./file1", O_RDWR);
if(fd == -1) { // 检查文件是否成功打开
printf("Unable to open file\n"); // 若文件打开失败，输出错误信息
return 1; // 返回错误码1
}
printf("open success : fd = %d\n", fd); // 打印成功打开文件的文件描述符
// 尝试将buf中的字符串写入打开的文件
int n_write = write(fd, buf, strlen(buf));
if(n_write != -1) { // 检查写入是否成功
printf("write %d bytes to file\n", n_write); // 输出写入的字节数
} else {
printf("Failed to write to file\n"); // 若写入失败，输出错误信息
}
close(fd); // 关闭文件描述符，释放资源
return 0; // 程序正常结束
}
例子10 清空文件内容，写入字符串
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close，以及write
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc和free
int main()
{
int fd; // 定义一个整型变量fd，用于存储文件描述符
char *buf = "test"; // 定义要写入的字符串常量
// 尝试以读写模式打开文件file1，如果文件已存在，则将其长度截为0（清空文件）
fd = open("./file1", O_RDWR | O_TRUNC);
if(fd == -1) { // 检查文件是否成功打开
printf("Unable to open file\n"); // 若文件打开失败，输出错误信息
return 1; // 返回错误码1
}
printf("open success : fd = %d\n", fd); // 打印成功打开文件的文件描述符
// 尝试将buf中的字符串写入打开的文件
int n_write = write(fd, buf, strlen(buf));
if(n_write != -1) { // 检查写入是否成功
printf("write %d bytes to file\n", n_write); // 输出写入的字节数
} else {
printf("Failed to write to file\n"); // 若写入失败，输出错误信息
}
close(fd); // 关闭文件描述符，释放资源
return 0; // 程序正常结束
}
例子11 创建一个新文件
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义，例如mode_t
#include <fcntl.h> // 包含文件控制定义，例如文件打开模式
#include <stdio.h> // 包含标准输入输出函数
#include <unistd.h> // 包含POSIX操作系统API
#include <string.h> // 包含字符串处理函数
#include <stdlib.h> // 包含标准库函数
int main()
{
int fd; // 文件描述符，用于存储creat函数的返回值
// 创建一个新文件，位于路径"/home/CLC/file1"
// S_IRWXU是文件权限标志，它设置文件拥有者具有读、写和执行权限
fd = creat("file1", S_IRWXU);
if (fd == -1) { // 检查文件是否成功创建
perror("Failed to create file"); // 使用perror输出错误原因
return 1; // 返回错误码1，表示出现错误
}
close(fd); // 成功创建文件后，关闭文件描述符
return 0; // 程序正常结束
}
例子12 标准输入读取一定数量字符，写入到标准输出
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如read和write
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含标准库函数
int main()
{
char readBuf[128]; // 创建一个字符数组，用于存储从标准输入读取的数据
// 从标准输入（文件描述符0）读取最多5个字节的数据到readBuf中
int n_read = read(0, readBuf, 5);
// 将读取的字符串（readBuf）写入到标准输出（文件描述符1）
// strlen(readBuf)可能不准确，因为read不会在字符串末尾添加'\0'
int n_write = write(1, readBuf, strlen(readBuf));
// 输出换行符和完成消息
printf("\ndone!\n");
return 0; // 程序正常结束
}
例子13 文件复制功能
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close、read、write，及lseek
#include <string.h> // 包含字符串处理函数，如strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc、free和exit
int main(int argc, char **argv)
{
int fdSrc, fdDes; // 定义两个文件描述符，分别用于源文件和目标文件
char *readBuf = NULL; // 定义字符指针，用于存储读取的文件内容
if(argc != 3){ // 检查命令行参数数量是否正确
printf("parameter error\n"); // 如果参数不正确，输出错误信息
exit(-1); // 非正常退出程序
}
// 打开源文件，文件模式为读写
fdSrc = open(argv[1], O_RDWR);
if (fdSrc == -1) { // 检查文件是否成功打开
perror("Failed to open source file");
exit(-1);
}
// 使用lseek获取文件大小
int size = lseek(fdSrc, 0, SEEK_END);
// 将文件指针重置到文件开始处
lseek(fdSrc, 0, SEEK_SET);
// 根据文件大小动态分配内存，加8是为了额外空间，防止溢出
readBuf = (char *)malloc(sizeof(char) * size + 8);
if (readBuf == NULL) { // 检查内存分配是否成功
perror("Memory allocation failed");
close(fdSrc);
exit(-1);
}
// 从源文件中读取全部数据到内存
int n_read = read(fdSrc, readBuf, size);
if (n_read == -1) { // 检查读取是否成功
perror("Failed to read source file");
free(readBuf);
close(fdSrc);
exit(-1);
}
// 打开目标文件，文件模式为读写，如果文件不存在则创建，如果文件存在则截断为0
fdDes = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0600);
if (fdDes == -1) { // 检查文件是否成功打开
perror("Failed to open destination file");
free(readBuf);
close(fdSrc);
exit(-1);
}
// 将读取的数据写入目标文件
int n_write = write(fdDes, readBuf, strlen(readBuf));
if (n_write == -1) { // 检查写入是否成功
perror("Failed to write to destination file");
}
// 关闭两个文件描述符
close(fdSrc);
close(fdDes);
// 释放动态分配的内存
free(readBuf);
return 0; // 程序正常结束
}
例子14 搜索字符串，修改字符串内容，写回文件
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close、read、write，及lseek
#include <string.h> // 包含字符串处理函数，如strstr和strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc、free和exit
int main(int argc, char **argv)
{
int fdSrc; // 文件描述符，用于源文件
char *readBuf = NULL; // 指针，用于存储读取的文件内容
if(argc != 2){ // 检查命令行参数数量是否正确
printf("parameter error\n"); // 如果参数不正确，输出错误信息
exit(-1); // 非正常退出程序
}
// 打开源文件，文件模式为读写
fdSrc = open(argv[1], O_RDWR);
if (fdSrc == -1) { // 检查文件是否成功打开
perror("Failed to open source file");
exit(-1);
}
// 使用lseek获取文件大小
int size = lseek(fdSrc, 0, SEEK_END);
// 将文件指针重置到文件开始处
lseek(fdSrc, 0, SEEK_SET);
// 根据文件大小动态分配内存，加8是为了额外空间，防止溢出
readBuf = (char *)malloc(sizeof(char) * size + 8);
if (readBuf == NULL) { // 检查内存分配是否成功
perror("Memory allocation failed");
close(fdSrc);
exit(-1);
}
// 从源文件中读取全部数据到内存
int n_read = read(fdSrc, readBuf, size);
if (n_read == -1) { // 检查读取是否成功
perror("Failed to read source file");
free(readBuf);
close(fdSrc);
exit(-1);
}
// 使用strstr查找字符串"LENG="，返回第一次出现的位置
char *p = strstr(readBuf, "LENG=");
if(p == NULL){ // 如果没有找到字符串
printf("not found\n");
free(readBuf);
close(fdSrc);
exit(-1);
}
// 移动指针到"LENG="后的第一个字符
p += strlen("LENG=");
// 修改找到的位置的字符为'5'
*p = '5';
// 将文件指针重置到文件开始处
lseek(fdSrc, 0, SEEK_SET);
// 将修改后的内容写回文件
int n_write = write(fdSrc, readBuf, strlen(readBuf));
if (n_write == -1) { // 检查写入是否成功
perror("Failed to write to source file");
}
// 关闭文件描述符
close(fdSrc);
// 释放动态分配的内存
free(readBuf);
return 0; // 程序正常结束
}
例子15 查找特定标记，并修改紧跟在该标记之后的字符
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close、read、write，及lseek
#include <string.h> // 包含字符串处理函数，如strstr和strlen
#include <stdlib.h> // 包含通用工具库函数，如malloc、free和exit
int main(int argc, char **argv)
{
int fdSrc; // 文件描述符，用于源文件
char *readBuf = NULL; // 指针，用于存储读取的文件内容
if(argc != 2){ // 检查命令行参数数量是否正确
printf("parameter error\n"); // 如果参数不正确，输出错误信息
exit(-1); // 非正常退出程序
}
// 打开源文件，文件模式为读写
fdSrc = open(argv[1], O_RDWR);
if (fdSrc == -1) { // 检查文件是否成功打开
perror("Failed to open source file");
exit(-1);
}
// 使用lseek获取文件大小
int size = lseek(fdSrc, 0, SEEK_END);
// 将文件指针重置到文件开始处
lseek(fdSrc, 0, SEEK_SET);
// 根据文件大小动态分配内存，加8是为了额外空间，防止溢出
readBuf = (char *)malloc(sizeof(char) * size + 8);
if (readBuf == NULL) { // 检查内存分配是否成功
perror("Memory allocation failed");
close(fdSrc);
exit(-1);
}
// 从源文件中读取全部数据到内存
int n_read = read(fdSrc, readBuf, size);
if (n_read == -1) { // 检查读取是否成功
perror("Failed to read source file");
free(readBuf);
close(fdSrc);
exit(-1);
}
// 使用strstr查找字符串"LENG="，返回第一次出现的位置
char *p = strstr(readBuf, "LENG=");
if(p == NULL){ // 如果没有找到字符串
printf("not found\n");
free(readBuf);
close(fdSrc);
exit(-1);
}
// 移动指针到"LENG="后的第一个字符
p += strlen("LENG=");
// 修改找到的位置的字符为数值5
*p = 5;
// 将文件指针重置到文件开始处
lseek(fdSrc, 0, SEEK_SET);
// 将修改后的内容写回文件
int n_write = write(fdSrc, readBuf, strlen(readBuf));
if (n_write == -1) { // 检查写入是否成功
perror("Failed to write to source file");
}
// 关闭文件描述符
close(fdSrc);
// 释放动态分配的内存
free(readBuf);
return 0; // 程序正常结束
}
例子16 一个文件中写入一个整数，然后重新读取这个整数
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close、read、write，及lseek
#include <string.h> // 包含字符串处理函数
#include <stdlib.h> // 包含通用工具库函数
int main()
{
int fd; // 文件描述符，用于源文件
int data = 100; // 定义并初始化一个整数data为100
int data2 = 0; // 定义另一个整数data2用于接收从文件读取的数据
// 打开名为"./file1"的文件，文件模式为读写
fd = open("./file1", O_RDWR);
if (fd == -1) { // 检查文件是否成功打开
perror("Failed to open file");
exit(-1);
}
// 向文件写入整数data
int n_write = write(fd, &data, sizeof(int));
if (n_write != sizeof(int)) { // 检查是否成功写入了整个int
perror("Failed to write complete data");
close(fd);
exit(-1);
}
// 将文件指针重置到文件开始处
lseek(fd, 0, SEEK_SET);
// 从文件中读取整数到data2
int n_read = read(fd, &data2, sizeof(int));
if (n_read != sizeof(int)) { // 检查是否成功读取了整个int
perror("Failed to read data");
close(fd);
exit(-1);
}
// 打印读取的数据
printf("read %d \n", data2);
// 关闭文件描述符
close(fd);
return 0; // 程序正常结束
}
例子17 向一个文件中写入一个结构体，读取这个结构体
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close、read、write，及lseek
#include <string.h> // 包含字符串处理函数
#include <stdlib.h> // 包含通用工具库函数
// 定义一个结构体Test，包含一个整数a和一个字符c
struct Test
{
int a;
char c;
};
int main()
{
int fd; // 文件描述符，用于源文件
struct Test data = {100, 'a'}; // 创建并初始化结构体data
struct Test data2; // 创建另一个结构体data2用于接收从文件读取的数据
// 打开名为"./file1"的文件，文件模式为读写
fd = open("./file1", O_RDWR);
if (fd == -1) { // 检查文件是否成功打开
perror("Failed to open file");
exit(-1);
}
// 向文件写入结构体data
int n_write = write(fd, &data, sizeof(struct Test));
if (n_write != sizeof(struct Test)) { // 检查是否成功写入了整个结构体
perror("Failed to write complete data");
close(fd);
exit(-1);
}
// 将文件指针重置到文件开始处
lseek(fd, 0, SEEK_SET);
// 从文件中读取结构体到data2
int n_read = read(fd, &data2, sizeof(struct Test));
if (n_read != sizeof(struct Test)) { // 检查是否成功读取了整个结构体
perror("Failed to read data");
close(fd);
exit(-1);
}
// 打印读取的数据，显示结构体data2中的整数和字符
printf("read %d,%c \n", data2.a, data2.c);
// 关闭文件描述符
close(fd);
return 0; // 程序正常结束
}
例子18 写入一个结构体数组，读取这些结构体
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义，如文件打开模式
#include <stdio.h> // 包含标准输入输出函数，如printf
#include <unistd.h> // 包含POSIX操作系统API，如open、close、read、write，及lseek
#include <string.h> // 包含字符串处理函数
#include <stdlib.h> // 包含通用工具库函数
// 定义一个结构体Test，包含一个整数a和一个字符c
struct Test
{
int a;
char c;
};
int main()
{
int fd; // 文件描述符，用于源文件
// 创建并初始化结构体数组data，包含两个元素
struct Test data[2] = {{100, 'a'}, {101, 'b'}};
struct Test data2[2]; // 创建另一个结构体数组data2用于接收从文件读取的数据
// 打开名为"./file1"的文件，文件模式为读写
fd = open("./file1", O_RDWR);
if (fd == -1) { // 检查文件是否成功打开
perror("Failed to open file");
exit(-1);
}
// 向文件写入结构体数组data
int n_write = write(fd, &data, sizeof(struct Test) * 2);
if (n_write != sizeof(struct Test) * 2) { // 检查是否成功写入了整个数组
perror("Failed to write complete data");
close(fd);
exit(-1);
}
// 将文件指针重置到文件开始处
lseek(fd, 0, SEEK_SET);
// 从文件中读取结构体数组到data2
int n_read = read(fd, &data2, sizeof(struct Test) * 2);
if (n_read != sizeof(struct Test) * 2) { // 检查是否成功读取了整个数组
perror("Failed to read data");
close(fd);
exit(-1);
}
// 打印读取的数据，显示数组中每个元素的整数和字符
printf("read %d,%c \n", data2[0].a, data2[0].c);
printf("read %d,%c \n", data2[1].a, data2[1].c);
// 关闭文件描述符
close(fd);
return 0; // 程序正常结束
}
fopen, fwrite, fread, 和 fseek 函数来操作文件
例子19 写入一个字符串到文件，然后读取
#include <stdio.h> // 包含标准输入输出函数库
#include <string.h> // 包含字符串处理函数库
int main()
{
FILE *fp; // 文件指针，用于操作文件
char *str = "helloworld"; // 要写入文件的字符串
char readBuf[128] = {0}; // 读缓冲区，初始化为0
// 使用"w+"模式打开文件，该模式支持读写操作，如果文件不存在则创建，如果存在则清空
fp = fopen("./text.txt", "w+");
if (fp == NULL) { // 检查文件是否成功打开
perror("Failed to open file");
return -1;
}
// 将字符串写入文件，每个元素大小为sizeof(char)，元素个数为strlen(str)，写入文件fp
fwrite(str, sizeof(char), strlen(str), fp);
// 重新定位文件指针到文件的开始，准备读取内容
fseek(fp, 0, SEEK_SET);
// 从文件中读取数据到readBuf，每个元素大小为sizeof(char)，要读取的元素个数为strlen(str)
fread(readBuf, sizeof(char), strlen(str), fp);
// 输出读取到的数据
printf("read data: %s\n", readBuf);
// 关闭文件
fclose(fp);
return 0; // 程序正常结束
}
例子20 文件中写入一个字符串，然后重新读取这个字符串
#include <stdio.h> // 包含标准输入输出函数库
#include <string.h> // 包含字符串处理函数库
int main()
{
FILE *fp; // 定义一个FILE类型的指针，用于操作文件
char *str = "helloworld"; // 定义一个字符串，用于写入文件
char readBuf[128] = {0}; // 定义一个读缓冲区，并初始化所有元素为0
// 以读写模式打开一个名为"text.txt"的文件，如果文件不存在则创建，如果存在则清空内容
fp = fopen("./text.txt", "w+");
if (fp == NULL) { // 检查文件是否成功打开
perror("Failed to open file");
return -1;
}
// 将字符串str写入文件，写入长度为strlen(str)*sizeof(char)，即字符串的长度，单位是字节数
fwrite(str, sizeof(char) * strlen(str), 1, fp);
// 将文件内的位置指针重置到文件的开始
fseek(fp, 0, SEEK_SET);
// 从文件中读取数据到readBuf，读取的长度和写入长度一样
fread(readBuf, sizeof(char) * strlen(str), 1, fp);
// 打印读取到的数据
printf("read data: %s\n", readBuf);
// 关闭文件
fclose(fp);
return 0; // 程序正常结束
}
例子21 使用 fwrite 和 fread 函数来写入和读取文件内容大小
#include <stdio.h> // 包含标准输入输出函数库
#include <string.h> // 包含字符串处理函数库
int main()
{
FILE *fp; // 定义一个FILE类型的指针，用于文件操作
char *str = "helloworld"; // 要写入文件的字符串
char readBuf[128] = {0}; // 定义一个读缓冲区，并初始化所有元素为0
// 以读写模式打开一个名为"chen.txt"的文件，如果文件不存在则创建，如果存在则清空内容
fp = fopen("./text.txt", "w+");
if (fp == NULL) { // 检查文件是否成功打开
perror("Failed to open file");
return -1;
}
// 尝试写入100个字符大小的数据，但实际上str长度小于100，因此会写入实际字符串长度加上未定义内容直到100字符
int nwrite = fwrite(str, sizeof(char), 100, fp);
// 重置文件指针到文件开头，以便从头开始读取文件
fseek(fp, 0, SEEK_SET);
// 从文件中读取与原始字符串长度相同的数据到readBuf
int nread = fread(readBuf, sizeof(char), strlen(str), fp);
// 输出读取到的数据
printf("read data: %s\n", readBuf);
printf("read=%d, write=%d\n", nread, nwrite); // 打印实际读写的字符数
// 关闭文件
fclose(fp);
return 0; // 程序正常结束
}
例子22 写入一个字符串，读取这个字符串，显示信息字节数
#include <stdio.h> // 包含标准输入输出函数库
#include <string.h> // 包含字符串处理函数库
int main()
{
FILE *fp; // 定义一个FILE类型的指针，用于操作文件
char *str = "chenlichen hen shuai"; // 定义一个字符串，用于写入文件
char readBuf[128] = {0}; // 定义一个读缓冲区，并初始化所有元素为0
// 以读写模式打开一个名为"chen.txt"的文件，如果文件不存在则创建，如果存在则清空内容
fp = fopen("./chen.txt", "w+");
if (fp == NULL) { // 检查文件是否成功打开
perror("Failed to open file");
return -1;
}
// 将字符串str写入文件，使用sizeof(char)*strlen(str)计算需要写入的总字节数，写入1个这样的单位
int nwrite = fwrite(str, sizeof(char) * strlen(str), 1, fp);
// 重置文件指针到文件开头，以便从头开始读取文件
fseek(fp, 0, SEEK_SET);
// 从文件中读取数据到readBuf，读取长度为strlen(str)个字符，尝试读取100个这样的单位
int nread = fread(readBuf, sizeof(char) * strlen(str), 100, fp);
// 输出读取到的数据
printf("read data: %s\n", readBuf);
// 打印实际读写的字节数
printf("read=%d, write=%d\n", nread, nwrite);
// 关闭文件
fclose(fp);
return 0; // 程序正常结束
}
例子23 使用 fwrite 和 fread 写入读取结构体到文件
#include <sys/types.h> // 包含系统数据类型定义
#include <sys/stat.h> // 包含文件状态定义
#include <fcntl.h> // 包含文件控制定义
#include <stdio.h> // 包含标准输入输出函数库
#include <unistd.h> // 包含POSIX操作系统API，如close
#include <string.h> // 包含字符串处理函数
#include <stdlib.h> // 包含标准库函数，如exit
// 定义一个结构体Test，包含一个整数和一个字符
struct Test
{
int a;
char c;
};
int main()
{
FILE *fp; // 定义一个FILE类型的指针，用于文件操作
struct Test data = {100, 'a'}; // 创建并初始化结构体data
struct Test data2; // 创建另一个结构体data2用于接收从文件读取的数据
// 以读写模式打开一个名为"file1"的文件，如果文件不存在则创建，如果存在则清空内容
fp = fopen("./file1", "w+");
if (fp == NULL) { // 检查文件是否成功打开
perror("Failed to open file");
return -1;
}
// 将结构体data写入文件
int n_write = fwrite(&data, sizeof(struct Test), 1, fp);
if (n_write != 1) { // 检查是否成功写入一个结构体
perror("Failed to write data");
fclose(fp);
return -1;
}
// 将文件内的位置指针重置到文件的开始
fseek(fp, 0, SEEK_SET);
// 从文件中读取结构体到data2
int n_read = fread(&data2, sizeof(struct Test), 1, fp);
if (n_read != 1) { // 检查是否成功读取一个结构体
perror("Failed to read data");
fclose(fp);
return -1;
}
// 打印读取的数据，显示结构体data2中的整数和字符
printf("read %d,%c \n", data2.a, data2.c);
// 关闭文件
fclose(fp);
return 0; // 程序正常结束
}
例子24 fputc将一个字符串逐字符写入到一个文件中
#include <stdio.h> // 包含标准输入输出函数库
#include <string.h> // 包含字符串处理函数库
int main()
{
FILE *fp; // 定义一个FILE类型的指针，用于文件操作
int i; // 循环控制变量
char *str = "helloworld!"; // 定义并初始化一个字符串
int len = strlen(str); // 计算字符串的长度
// 以读写模式打开一个名为"test.txt"的文件，如果文件不存在则创建，如果存在则清空内容
fp = fopen("./test.txt", "w+");
if (fp == NULL) { // 检查文件是否成功打开
perror("Failed to open file");
return -1;
}
// 循环遍历字符串中的每一个字符
for(i = 0; i < len; i++) {
// 写入当前字符到文件中，*str是指向当前字符的指针
fputc(*str, fp);
// 指针后移，指向下一个字符
str++;
}
// 关闭文件
fclose(fp);
return 0; // 程序正常结束
}
例子25 fgetc从一个文件中逐字符读取内容
#include <stdio.h> // 包含标准输入输出函数库
#include <string.h> // 包含字符串处理函数库
int main()
{
FILE *fp; // 定义一个FILE类型的指针，用于文件操作
int i; // 未使用的变量，可以移除
char c; // 用于存储从文件读取的每个字符
// 以只读模式打开一个名为"test.txt"的文件
fp = fopen("./test.txt", "r");
if (fp == NULL) { // 检查文件是否成功打开
perror("Failed to open file");
return -1;
}
// 使用feof(fp)来检测文件结束，当未到达文件末尾时，循环继续
while(!feof(fp)) { // 如果没有达到文件末尾
c = fgetc(fp); // 从文件中读取一个字符
// 在未检测到文件结束前，最后一次循环可能读取到EOF
if (feof(fp)) {
break; // 如果读取到文件结束，跳出循环
}
printf("%c", c); // 打印读取的字符
}
// 关闭文件
fclose(fp);
return 0; // 程序正常结束
}
2472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
