C语言I/O文件编程详解

文件I/O（输入/输出）是编程中一个非常重要的部分，它使得程序可以与外部数据进行交互，进行数据的存储和读取。C语言提供了强大的文件I/O功能，能够方便地操作文件，读取和写入数据。本文将详细介绍C语言中的文件I/O编程，包括文件的基本操作、文件读写模式、文件指针、缓冲区、二进制文件操作、文件定位、错误处理、以及实际应用中的案例和最佳实践。

文件的基本概念

文件是存储在计算机上的一段数据，通常用于存储长期数据或需要在程序之间传递的数据。在C语言中，文件是通过标准库中的一组函数来进行操作的，这些函数主要定义在<stdio.h>头文件中。

文件指针

在C语言中，文件是通过文件指针来进行操作的。文件指针是一个指向FILE类型结构的指针，用于标识文件的当前状态和位置。FILE结构在<stdio.h>头文件中定义。

  1. FILE *filePointer;

文件操作的基本步骤

  1. 打开文件：使用fopen函数打开文件，并返回文件指针。
  2. 读写文件：使用各种I/O函数进行文件的读写操作。
  3. 关闭文件：使用fclose函数关闭文件，释放资源。

文件的打开和关闭

fopen函数

fopen函数用于打开文件，其基本语法如下：

  1. FILE *fopen(const char *filename, const char *mode);
  • filename：文件名，包含路径的字符串。
  • mode：文件打开模式。

文件打开模式包括：

  • "r"：以只读方式打开文件。文件必须存在。
  • "w"：以写入方式打开文件。文件不存在则创建，存在则清空内容。
  • "a"：以追加方式打开文件。文件不存在则创建，存在则在文件末尾追加内容。
  • "r+"：以读写方式打开文件。文件必须存在。
  • "w+"：以读写方式打开文件。文件不存在则创建，存在则清空内容。
  • "a+"：以读写方式打开文件。文件不存在则创建，存在则在文件末尾追加内容。

例如，打开一个名为data.txt的文件：

  1. FILE *file = fopen("data.txt", "r");
  2. if (file == NULL) {
  3.     perror("Failed to open file");
  4.     return 1;
  5. }

fclose函数

fclose函数用于关闭文件，其基本语法如下：

  1. int fclose(FILE *stream);

例如，关闭前面打开的文件：

  1. fclose(file);

文件的读写操作

fgetc和fputc函数

fgetc函数用于从文件中读取一个字符，其基本语法如下：

  1. int fgetc(FILE *stream);

例如，读取文件中的一个字符：

  1. char ch = fgetc(file);

fputc函数用于向文件中写入一个字符，其基本语法如下：

  1. int fputc(int char, FILE *stream);

例如，向文件中写入一个字符：

  1. fputc('A', file);

fgets和fputs函数

fgets函数用于从文件中读取一行，其基本语法如下：

  1. char *fgets(char *str, int n, FILE *stream);

例如，读取文件中的一行：

  1. char buffer[100];
  2. fgets(buffer, 100, file);

fputs函数用于向文件中写入一个字符串，其基本语法如下：

  1. int fputs(const char *str, FILE *stream);

例如，向文件中写入一个字符串：

  1. fputs("Hello, World!", file);

fread和fwrite函数

fread函数用于从文件中读取数据块，其基本语法如下：

  1. size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

例如，从文件中读取数据块：

  1. int data[10];
  2. fread(data, sizeof(int), 10, file);

fwrite函数用于向文件中写入数据块，其基本语法如下：

  1. size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

例如，向文件中写入数据块：

  1. fwrite(data, sizeof(int), 10, file);

fprintf和fscanf函数

fprintf函数用于向文件中写入格式化数据，其基本语法如下：

  1. int fprintf(FILE *stream, const char *format, ...);

例如，向文件中写入格式化数据：

  1. fprintf(file, "Name: %s, Age: %d\n", "John", 30);

fscanf函数用于从文件中读取格式化数据，其基本语法如下：

  1. int fscanf(FILE *stream, const char *format, ...);

例如，从文件中读取格式化数据：

  1. char name[20];
  2. int age;
  3. fscanf(file, "Name: %s, Age: %d", name, &age);

文件定位和缓冲

ftell和fseek函数

ftell函数用于获取文件指针的当前位置，其基本语法如下：

  1. long ftell(FILE *stream);

例如，获取文件指针的当前位置：

  1. long position = ftell(file);

fseek函数用于设置文件指针的位置，其基本语法如下：

  1. int fseek(FILE *stream, long offset, int whence);
  • offset：偏移量。
  • whence：基准位置，可以是SEEK_SET（文件开头）、SEEK_CUR（当前位置）或SEEK_END（文件末尾）。

例如，将文件指针设置到文件开头：

  1. fseek(file, 0, SEEK_SET);

rewind函数

rewind函数用于将文件指针设置到文件开头，其基本语法如下：

  1. void rewind(FILE *stream);

例如，将文件指针设置到文件开头：

  1. rewind(file);

缓冲区管理

文件I/O通常使用缓冲区提高效率。缓冲区可以减少系统调用的次数，提高I/O性能。标准库提供了几种函数用于缓冲区管理：

  • setbuf：设置缓冲区。
  • setvbuf：设置缓冲区模式和大小。

例如，设置文件的全缓冲区：

  1. char buffer[BUFSIZ];
  2. setbuf(file, buffer);

设置文件的行缓冲区：

  1. setvbuf(file, buffer, _IOLBF, BUFSIZ);

二进制文件操作

二进制文件的读写

与文本文件不同，二进制文件以原始二进制数据形式存储，适用于存储图像、音频、视频等数据。操作二进制文件时，需要使用带有b的文件模式，例如"rb"、"wb"、"ab"等。

例如，读写二进制文件：

  1. FILE *file = fopen("data.bin", "wb");
  2. if (file == NULL) {
  3.     perror("Failed to open file");
  4.     return 1;
  5. }
  7. int data[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  8. fwrite(data, sizeof(int), 10, file);
  9. fclose(file);
  11. file = fopen("data.bin", "rb");
  12. if (file == NULL) {
  13.     perror("Failed to open file");
  14.     return 1;
  15. }
  17. int readData[10];
  18. fread(readData, sizeof(int), 10, file);
  19. for (int i = 0; i < 10; i++) {
  20.     printf("%d ", readData[i]);
  21. }
  22. printf("\n");
  23. fclose(file);

文件错误处理

文件操作中的错误

在进行文件操作时，可能会遇到各种错误，例如文件不存在、权限不足、磁盘已满等。C语言提供了一组错误处理函数和宏，用于检测和处理文件操作中的错误。

perror函数

perror函数用于输出错误信息，其基本语法如下：

  1. void perror(const char *s);

例如，打开文件失败时输出错误信息：

  1. FILE *file = fopen("data.txt", "r");
  2. if (file == NULL) {
  3.     perror("Failed to open file");
  4.     return 1;
  5. }

ferror函数

ferror函数用于检查文件流是否发生错误，其基本语法如下：

  1. int ferror(FILE *stream);

例如，检查文件流是否发生错误：

  1. if (ferror(file)) {
  2.     perror("File error");
  3. }

feof函数

feof函数用于检查文件流是否到达文件末

尾，其基本语法如下：

  1. int feof(FILE *stream);

例如，检查文件流是否到达文件末尾：

  1. if (feof(file)) {
  2.     printf("End of file reached\n");
  3. }

清除错误

clearerr函数用于清除文件流的错误状态和文件末尾标志，其基本语法如下：

  1. void clearerr(FILE *stream);

例如，清除文件流的错误状态和文件末尾标志：

  1. clearerr(file);

实际应用中的案例分析

文本文件处理

文本文件处理是文件I/O的常见应用场景。以下示例展示了如何使用C语言读取和处理文本文件：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main() {
  5.     FILE *file = fopen("data.txt", "r");
  6.     if (file == NULL) {
  7.         perror("Failed to open file");
  8.         return 1;
  9.     }
  11.     char buffer[256];
  12.     while (fgets(buffer, sizeof(buffer), file) != NULL) {
  13.         printf("%s", buffer);
  14.     }
  16.     fclose(file);
  17.     return 0;
  18. }

二进制文件处理

二进制文件处理是另一个常见应用场景。以下示例展示了如何使用C语言读取和处理二进制文件：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main() {
  5.     FILE *file = fopen("data.bin", "rb");
  6.     if (file == NULL) {
  7.         perror("Failed to open file");
  8.         return 1;
  9.     }
  11.     int data[10];
  12.     fread(data, sizeof(int), 10, file);
  13.     for (int i = 0; i < 10; i++) {
  14.         printf("%d ", data[i]);
  15.     }
  16.     printf("\n");
  18.     fclose(file);
  19.     return 0;
  20. }

记录日志

记录日志是文件I/O的实际应用之一。以下示例展示了如何使用C语言记录日志：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  5. void logMessage(const char *message) {
  6.     FILE *file = fopen("log.txt", "a");
  7.     if (file == NULL) {
  8.         perror("Failed to open log file");
  9.         return;
  10.     }
  12.     time_t now = time(NULL);
  13.     char *timeStr = ctime(&now);
  14.     timeStr[strlen(timeStr) - 1] = '\0'; // 去除换行符
  16.     fprintf(file, "[%s] %s\n", timeStr, message);
  17.     fclose(file);
  18. }
  20. int main() {
  21.     logMessage("Program started");
  22.     logMessage("Performing some operations...");
  23.     logMessage("Program ended");
  24.     return 0;
  25. }

配置文件解析

配置文件解析是另一个实际应用场景。以下示例展示了如何使用C语言解析简单的配置文件：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #define MAX_LINE_LENGTH 256
  7. void parseConfig(const char *filename) {
  8.     FILE *file = fopen(filename, "r");
  9.     if (file == NULL) {
  10.         perror("Failed to open config file");
  11.         return;
  12.     }
  14.     char line[MAX_LINE_LENGTH];
  15.     while (fgets(line, sizeof(line), file) != NULL) {
  16.         char *key = strtok(line, "=");
  17.         char *value = strtok(NULL, "\n");
  18.         if (key && value) {
  19.             printf("Key: %s, Value: %s\n", key, value);
  20.         }
  21.     }
  23.     fclose(file);
  24. }
  26. int main() {
  27.     parseConfig("config.txt");
  28.     return 0;
  29. }

读取和写入结构体

读取和写入结构体是文件I/O的另一个实际应用。以下示例展示了如何使用C语言读取和写入结构体：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef struct {
  5.     int id;
  6.     char name[50];
  7.     float salary;
  8. } Employee;
  10. void writeEmployee(const char *filename, const Employee *emp) {
  11.     FILE *file = fopen(filename, "wb");
  12.     if (file == NULL) {
  13.         perror("Failed to open file");
  14.         return;
  15.     }
  17.     fwrite(emp, sizeof(Employee), 1, file);
  18.     fclose(file);
  19. }
  21. void readEmployee(const char *filename, Employee *emp) {
  22.     FILE *file = fopen(filename, "rb");
  23.     if (file == NULL) {
  24.         perror("Failed to open file");
  25.         return;
  26.     }
  28.     fread(emp, sizeof(Employee), 1, file);
  29.     fclose(file);
  30. }
  32. int main() {
  33.     Employee emp1 = {1, "Alice", 50000.0};
  34.     writeEmployee("employee.dat", &emp1);
  36.     Employee emp2;
  37.     readEmployee("employee.dat", &emp2);
  38.     printf("ID: %d, Name: %s, Salary: %.2f\n", emp2.id, emp2.name, emp2.salary);
  40.     return 0;
  41. }

文件I/O的最佳实践

关闭文件

确保在操作完成后关闭文件，避免资源泄漏。例如：

  1. FILE *file = fopen("data.txt", "r");
  2. if (file == NULL) {
  3.     perror("Failed to open file");
  4.     return 1;
  5. }
  7. // 文件操作
  9. fclose(file);

检查错误

在进行文件操作时，检查返回值和错误码，及时处理错误。例如：

  1. FILE *file = fopen("data.txt", "r");
  2. if (file == NULL) {
  3.     perror("Failed to open file");
  4.     return 1;
  5. }
  7. // 文件操作
  9. if (ferror(file)) {
  10.     perror("File error");
  11. }
  13. fclose(file);

使用缓冲区

使用缓冲区可以提高文件I/O的性能。例如：

  1. char buffer[BUFSIZ];
  2. setvbuf(file, buffer, _IOFBF, BUFSIZ);

避免使用魔法数字

在代码中避免使用魔法数字，使用常量或宏定义，提高代码的可读性和可维护性。例如：

  1. #define BUFFER_SIZE 256
  2. char buffer[BUFFER_SIZE];

使用二进制模式处理非文本文件

处理非文本文件时，使用二进制模式，避免数据被错误处理。例如：

  1. FILE *file = fopen("data.bin", "wb");
  2. if (file == NULL) {
  3.     perror("Failed to open file");
  4.     return 1;
  5. }
  7. // 二进制文件操作
  9. fclose(file);

高级文件I/O技术

文件锁定

在多进程或多线程环境中，文件锁定用于避免并发访问冲突。POSIX提供了文件锁定机制，可以使用flock函数实现文件锁定。

例如，使用flock函数进行文件锁定：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <fcntl.h>
  5. #include <sys/file.h>
  7. int main() {
  8.     int fd = open("data.txt", O_RDWR);
  9.     if (fd == -1) {
  10.         perror("Failed to open file");
  11.         return 1;
  12.     }
  14.     if (flock(fd, LOCK_EX) == -1) {
  15.         perror("Failed to lock file");
  16.         close(fd);
  17.         return 1;
  18.     }
  20.     // 文件操作
  22.     if (flock(fd, LOCK_UN) == -1) {
  23.         perror("Failed to unlock file");
  24.     }
  26.     close(fd);
  27.     return 0;
  28. }

内存映射文件

内存映射文件（Memory-Mapped File）技术用于将文件映射到内存地址空间，提高文件I/O性能。POSIX提供了mmap函数实现内存映射文件。

例如，使用mmap函数进行内存映射文件操作：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <fcntl.h>
  4. #include <sys/mman.h>
  5. #include <sys/stat.h>
  6. #include <unistd.h>
  8. int main() {
  9.     int fd = open("data.txt", O_RDONLY);
  10.     if (fd == -1) {
  11.         perror("Failed to open file");
  12.         return 1;
  13.     }
  15.     struct stat sb;
  16.     if (fstat(fd, &sb) == -1) {
  17.         perror("Failed to get file size");
  18.         close(fd);
  19.         return 1;
  20.     }
  22.     char *addr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
  23.     if (addr == MAP_FAILED) {
  24.         perror("Failed to map file");
  25.         close(fd);
  26.         return 1;
  27.     }
  29.     write(STDOUT_FILENO, addr, sb.st_size);
  31.     if (munmap(addr, sb.st_size) == -1) {
  32.         perror("Failed to unmap file");
  33.     }
  35.     close(fd);
  36.     return 0;
  37. }

非阻塞文件I/O

非阻塞文件I/O用于避免I/O操作阻塞程序执行，提高系统的响应速度。POSIX提供了设置文件描述符为非阻塞模式的方法。

例如，设置文件描述符为非阻塞模式：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <errno.h>
  7. int main() {
  8.     int fd = open("data.txt", O_RDONLY | O_NONBLOCK);
  9.     if (fd == -1) {
  10.         perror("Failed to open file");
  11.         return 1;
  12.     }
  14.     char
  16.  buffer[256];
  17.     ssize_t bytesRead;
  18.     while ((bytesRead = read(fd, buffer, sizeof(buffer))) != -1 || errno == EAGAIN) {
  19.         if (bytesRead > 0) {
  20.             write(STDOUT_FILENO, buffer, bytesRead);
  21.         }
  22.     }
  24.     if (bytesRead == -1) {
  25.         perror("Failed to read file");
  26.     }
  28.     close(fd);
  29.     return 0;
  30. }

多线程文件I/O

多线程文件I/O用于提高文件操作的并发性，适用于需要高性能I/O的应用场景。POSIX提供了多线程编程接口，可以使用pthread库实现多线程文件I/O。

例如，使用pthread库进行多线程文件I/O操作：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <pthread.h>
  5. void *readFile(void *arg) {
  6.     char *filename = (char *)arg;
  7.     FILE *file = fopen(filename, "r");
  8.     if (file == NULL) {
  9.         perror("Failed to open file");
  10.         return NULL;
  11.     }
  13.     char buffer[256];
  14.     while (fgets(buffer, sizeof(buffer), file) != NULL) {
  15.         printf("%s", buffer);
  16.     }
  18.     fclose(file);
  19.     return NULL;
  20. }
  22. int main() {
  23.     pthread_t thread1, thread2;
  25.     pthread_create(&thread1, NULL, readFile, "file1.txt");
  26.     pthread_create(&thread2, NULL, readFile, "file2.txt");
  28.     pthread_join(thread1, NULL);
  29.     pthread_join(thread2, NULL);
  31.     return 0;
  32. }

文件I/O的性能优化

使用大块读写

使用大块读写可以减少系统调用的次数，提高文件I/O性能。例如：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. #define BUFFER_SIZE 4096
  6. int main() {
  7.     FILE *input = fopen("input.txt", "rb");
  8.     FILE *output = fopen("output.txt", "wb");
  9.     if (input == NULL || output == NULL) {
  10.         perror("Failed to open file");
  11.         return 1;
  12.     }
  14.     char buffer[BUFFER_SIZE];
  15.     size_t bytesRead;
  16.     while ((bytesRead = fread(buffer, 1, BUFFER_SIZE, input)) > 0) {
  17.         fwrite(buffer, 1, bytesRead, output);
  18.     }
  20.     fclose(input);
  21.     fclose(output);
  22.     return 0;
  23. }

避免频繁打开和关闭文件

频繁打开和关闭文件会增加系统开销，尽量避免。例如：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. void logMessage(FILE *file, const char *message) {
  5.     fprintf(file, "%s\n", message);
  6.     fflush(file); // 立即刷新缓冲区，确保日志实时写入
  7. }
  9. int main() {
  10.     FILE *file = fopen("log.txt", "a");
  11.     if (file == NULL) {
  12.         perror("Failed to open log file");
  13.         return 1;
  14.     }
  16.     logMessage(file, "Program started");
  17.     logMessage(file, "Performing some operations...");
  18.     logMessage(file, "Program ended");
  20.     fclose(file);
  21.     return 0;
  22. }

使用内存映射文件

内存映射文件技术用于将文件映射到内存地址空间，提高文件I/O性能。例如：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <fcntl.h>
  4. #include <sys/mman.h>
  5. #include <sys/stat.h>
  6. #include <unistd.h>
  8. int main() {
  9.     int fd = open("data.txt", O_RDONLY);
  10.     if (fd == -1) {
  11.         perror("Failed to open file");
  12.         return 1;
  13.     }
  15.     struct stat sb;
  16.     if (fstat(fd, &sb) == -1) {
  17.         perror("Failed to get file size");
  18.         close(fd);
  19.         return 1;
  20.     }
  22.     char *addr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
  23.     if (addr == MAP_FAILED) {
  24.         perror("Failed to map file");
  25.         close(fd);
  26.         return 1;
  27.     }
  29.     write(STDOUT_FILENO, addr, sb.st_size);
  31.     if (munmap(addr, sb.st_size) == -1) {
  32.         perror("Failed to unmap file");
  33.     }
  35.     close(fd);
  36.     return 0;
  37. }

使用异步I/O

异步I/O技术用于在I/O操作时不阻塞程序执行，提高系统的响应速度。例如，使用POSIX的aio库实现异步I/O操作：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <fcntl.h>
  4. #include <aio.h>
  5. #include <unistd.h>
  6. #include <errno.h>
  8. int main() {
  9.     int fd = open("data.txt", O_RDONLY);
  10.     if (fd == -1) {
  11.         perror("Failed to open file");
  12.         return 1;
  13.     }
  15.     struct aiocb aio;
  16.     char buffer[256];
  18.     aio.aio_fildes = fd;
  19.     aio.aio_offset = 0;
  20.     aio.aio_buf = buffer;
  21.     aio.aio_nbytes = sizeof(buffer);
  22.     aio.aio_sigevent.sigev_notify = SIGEV_NONE;
  24.     if (aio_read(&aio) == -1) {
  25.         perror("Failed to start async read");
  26.         close(fd);
  27.         return 1;
  28.     }
  30.     while (aio_error(&aio) == EINPROGRESS) {
  31.         // 等待异步I/O操作完成
  32.     }
  34.     ssize_t bytesRead = aio_return(&aio);
  35.     if (bytesRead == -1) {
  36.         perror("Failed to complete async read");
  37.     } else {
  38.         write(STDOUT_FILENO, buffer, bytesRead);
  39.     }
  41.     close(fd);
  42.     return 0;
  43. }

结论

C语言中的文件I/O编程是一个非常重要的部分，它使得程序可以与外部数据进行交互，进行数据的存储和读取。本文详细介绍了C语言中的文件I/O编程，包括文件的基本操作、文件读写模式、文件指针、缓冲区、二进制文件操作、文件定位、错误处理、实际应用中的案例和最佳实践、高级文件I/O技术、文件I/O的性能优化等内容。通过掌握这些知识和技巧，程序员可以更好地利用文件I/O编写高效、可靠和可维护的C语言程序。希望本文对读者理解和掌握C语言的文件I/O编程有所帮助。