C语言文件操作详解（一）：文件的打开与关闭
目录
- 摘要
- 一、文件
- [1.1 文件是什么？](#1.1 文件是什么？)
- [1.2 文件的作用](#1.2 文件的作用)
- 二、数据文件
- 三、文件的打开与关闭
- [3.1 流和标准流](#3.1 流和标准流)
- [3.2 文件指针](#3.2 文件指针)
- [3.3 文件的打开(fopen函数)](#3.3 文件的打开(fopen函数))
- [3.4 文件的关闭(fclose函数)](#3.4 文件的关闭(fclose函数))
- 总结
- 参考文献
摘要
在C语言编程中，文件操作是一项至关重要的技能。无论是开发简单的命令行工具，还是构建复杂的系统软件，文件操作都扮演着不可或缺的角色。文件不仅是数据持久化存储的载体，也是程序与外部世界进行数据交换的重要接口。掌握C语言中的文件操作，对于提升编程能力和解决实际问题具有重要意义。
本文作为C语言文件操作系列的第一篇，将深入探讨文件的打开与关闭这两个基础而关键的操作。我们将从文件的基本概念入手，逐步深入到C语言中文件操作的具体实现，重点讲解fopen和fclose函数的使用方法、参数含义、返回值处理以及相关注意事项。通过丰富的代码示例和详细的理论分析，帮助读者建立扎实的文件操作基础，为后续学习更高级的文件操作技巧打下坚实的基础。
本文的目标读者是已经掌握C语言基本语法，希望深入学习文件操作的开发者。无论你是计算机专业的学生，还是希望提升编程技能的开发者，本文都将为你提供有价值的参考。
一、文件
1.1 文件是什么？
在计算机科学中，文件是一个逻辑概念，指的是存储在计算机外部存储器（如硬盘、固态硬盘、U盘等）上的数据集合。文件是操作系统进行数据管理的基本单位，它包含了用户或应用程序可以识别和处理的数据。
从物理层面看，文件是存储在存储介质上的一系列二进制数据的集合。这些数据按照特定的格式和组织方式进行存储，操作系统通过文件系统来管理这些文件的存储、访问和保护。
在C语言中，文件被抽象为一个数据流（stream），程序可以通过文件指针来访问和操作文件内容。这种抽象使得程序员可以不必关心文件在磁盘上的具体存储细节，而专注于数据的逻辑处理。
文件的分类：
-
按内容划分：
- 文本文件：由字符序列组成，每个字符通常采用ASCII、UTF-8等编码方式存储。文本文件可以用文本编辑器直接打开和编辑。
- 二进制文件：由二进制数据组成，如图像、音频、视频、可执行程序等。二进制文件需要特定的软件才能正确解析。
-
按用途划分：
- 程序文件：包括源程序文件（.c）、目标文件（.obj）、可执行文件（.exe）等。
- 数据文件：用于存储程序运行时需要处理的数据，如配置文件、日志文件、数据库文件等。
-
按访问方式划分：
- 顺序访问文件：数据只能按顺序从头到尾进行读写。
- 随机访问文件：可以直接访问文件的任意位置，支持前后移动文件指针。
文件的特性：
- 持久性：文件中的数据在计算机关闭后仍然存在，不会丢失。
- 共享性：多个程序可以同时访问同一个文件（可能有访问限制）。
- 命名和定位：每个文件都有唯一的名称和存储路径。
- 安全性：操作系统提供文件权限机制，控制不同用户对文件的访问。
1.2 文件的作用
文件在计算机系统和应用程序中发挥着至关重要的作用，主要体现在以下几个方面：
1. 数据持久化存储
程序运行时产生的数据通常存储在内存中，但内存是易失性存储介质，断电后数据会丢失。文件提供了将数据永久保存到磁盘等非易失性存储介质的能力，确保数据不会因为程序结束或计算机关机而丢失。
c
// 示例：将用户输入的数据保存到文件中
#include <stdio.h>
#include <string.h>
#define MAX_INPUT 1000
int main() {
char user_data[MAX_INPUT];
FILE *file;
printf("请输入要保存的数据（输入END结束）：\n");
// 打开文件用于写入
file = fopen("user_data.txt", "w");
if (file == NULL) {
printf("无法打开文件！\n");
return 1;
}
// 读取用户输入并写入文件
while (1) {
fgets(user_data, MAX_INPUT, stdin);
// 移除换行符
user_data[strcspn(user_data, "\n")] = '\0';
// 检查是否结束输入
if (strcmp(user_data, "END") == 0) {
break;
}
// 将数据写入文件
fprintf(file, "%s\n", user_data);
}
// 关闭文件
fclose(file);
printf("数据已保存到 user_data.txt 文件中。\n");
return 0;
}2. 程序配置和初始化
许多程序使用配置文件来存储运行参数、用户偏好设置等信息。这使得程序可以记住用户的选择，并在下次启动时恢复之前的设置。
c
// 示例：读取和写入配置文件
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// 配置结构体
typedef struct {
char username[50];
int theme; // 0:浅色, 1:深色
int language; // 0:中文, 1:英文
int autosave; // 0:关闭, 1:开启
} Config;
// 保存配置到文件
void save_config(const Config *config) {
FILE *file = fopen("config.cfg", "wb");
if (file == NULL) {
printf("无法保存配置文件！\n");
return;
}
// 将配置结构体写入文件
fwrite(config, sizeof(Config), 1, file);
fclose(file);
printf("配置已保存。\n");
}
// 从文件加载配置
int load_config(Config *config) {
FILE *file = fopen("config.cfg", "rb");
if (file == NULL) {
printf("未找到配置文件，使用默认配置。\n");
return 0; // 加载失败
}
// 从文件读取配置结构体
fread(config, sizeof(Config), 1, file);
fclose(file);
return 1; // 加载成功
}
// 显示配置
void display_config(const Config *config) {
printf("=== 当前配置 ===\n");
printf("用户名: %s\n", config->username);
printf("主题: %s\n", config->theme == 0 ? "浅色" : "深色");
printf("语言: %s\n", config->language == 0 ? "中文" : "英文");
printf("自动保存: %s\n", config->autosave == 0 ? "关闭" : "开启");
printf("================\n");
}
int main() {
Config config;
// 尝试加载现有配置
if (!load_config(&config)) {
// 使用默认配置
strcpy(config.username, "默认用户");
config.theme = 0;
config.language = 0;
config.autosave = 1;
}
// 显示当前配置
display_config(&config);
// 修改配置
printf("\n修改配置...\n");
strcpy(config.username, "新用户");
config.theme = 1; // 切换为深色主题
// 保存配置
save_config(&config);
return 0;
}3. 数据交换和通信
文件可以作为不同程序之间数据交换的媒介。例如，一个程序可以将计算结果保存到文件中，另一个程序可以读取该文件进行进一步处理。
c
// 示例：程序间通过文件交换数据
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// 程序A：生成数据并保存到文件
void program_a() {
FILE *file = fopen("data_exchange.dat", "wb");
if (file == NULL) {
printf("程序A：无法创建数据文件！\n");
return;
}
srand(time(NULL));
// 生成10个随机数并保存到文件
printf("程序A：生成随机数据...\n");
for (int i = 0; i < 10; i++) {
int num = rand() % 100;
printf(" 数据[%d] = %d\n", i, num);
fwrite(&num, sizeof(int), 1, file);
}
fclose(file);
printf("程序A：数据已保存到 data_exchange.dat\n");
}
// 程序B：从文件读取数据并处理
void program_b() {
FILE *file = fopen("data_exchange.dat", "rb");
if (file == NULL) {
printf("程序B：无法打开数据文件！\n");
return;
}
printf("程序B：读取并处理数据...\n");
int sum = 0;
int count = 0;
int num;
// 从文件读取数据并计算总和
while (fread(&num, sizeof(int), 1, file) == 1) {
printf(" 读取数据[%d] = %d\n", count, num);
sum += num;
count++;
}
fclose(file);
if (count > 0) {
printf("程序B：处理完成\n");
printf(" 数据个数：%d\n", count);
printf(" 数据总和：%d\n", sum);
printf(" 平均值：%.2f\n", (float)sum / count);
} else {
printf("程序B：文件中没有数据\n");
}
}
int main() {
printf("=== 程序A：数据生成 ===\n");
program_a();
printf("\n=== 程序B：数据处理 ===\n");
program_b();
return 0;
}4. 日志记录和调试
文件常用于记录程序的运行日志，帮助开发者了解程序的运行状态、诊断错误和进行性能分析。
c
// 示例：使用文件记录程序日志
#include <stdio.h>
#include <time.h>
#include <stdarg.h>
// 日志级别
typedef enum {
LOG_DEBUG,
LOG_INFO,
LOG_WARNING,
LOG_ERROR,
LOG_CRITICAL
} LogLevel;
// 日志文件名
#define LOG_FILE "program.log"
// 记录日志函数
void log_message(LogLevel level, const char *format, ...) {
FILE *log_file = fopen(LOG_FILE, "a");
if (log_file == NULL) {
printf("无法打开日志文件！\n");
return;
}
// 获取当前时间
time_t now = time(NULL);
struct tm *timeinfo = localtime(&now);
char time_str[20];
strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", timeinfo);
// 日志级别字符串
const char *level_str;
switch (level) {
case LOG_DEBUG: level_str = "DEBUG"; break;
case LOG_INFO: level_str = "INFO"; break;
case LOG_WARNING: level_str = "WARNING"; break;
case LOG_ERROR: level_str = "ERROR"; break;
case LOG_CRITICAL: level_str = "CRITICAL"; break;
default: level_str = "UNKNOWN"; break;
}
// 输出时间戳和日志级别
fprintf(log_file, "[%s] [%s] ", time_str, level_str);
// 输出日志内容
va_list args;
va_start(args, format);
vfprintf(log_file, format, args);
va_end(args);
// 添加换行符
fprintf(log_file, "\n");
// 如果是错误级别以上的日志，同时输出到控制台
if (level >= LOG_ERROR) {
printf("[%s] [%s] ", time_str, level_str);
va_start(args, format);
vprintf(format, args);
va_end(args);
printf("\n");
}
fclose(log_file);
}
// 显示日志文件内容
void show_log() {
FILE *log_file = fopen(LOG_FILE, "r");
if (log_file == NULL) {
printf("日志文件不存在或无法打开！\n");
return;
}
printf("=== 程序日志 ===\n");
char line[256];
while (fgets(line, sizeof(line), log_file) != NULL) {
printf("%s", line);
}
fclose(log_file);
printf("================\n");
}
// 清除日志文件
void clear_log() {
if (remove(LOG_FILE) == 0) {
printf("日志文件已清除。\n");
} else {
printf("无法清除日志文件。\n");
}
}
int main() {
// 记录各种级别的日志
log_message(LOG_INFO, "程序启动");
log_message(LOG_DEBUG, "初始化配置参数");
log_message(LOG_WARNING, "内存使用率超过80%%");
log_message(LOG_ERROR, "无法连接到数据库");
log_message(LOG_INFO, "用户登录成功，用户名: %s", "张三");
log_message(LOG_CRITICAL, "系统遇到严重错误，即将退出");
log_message(LOG_INFO, "程序退出");
// 显示日志内容
show_log();
// 可以选择清除日志
// clear_log();
return 0;
}5. 大数据处理
当处理的数据量超过内存容量时，程序可以使用文件作为临时存储或分批处理的媒介。
c
// 示例：处理大文件的技巧 - 分批读取
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BUFFER_SIZE 4096 // 缓冲区大小，4KB
#define MAX_LINES 1000 // 每次处理的最大行数
// 统计大文件中特定单词出现的次数
long long count_word_in_large_file(const char *filename, const char *target_word) {
FILE *file = fopen(filename, "r");
if (file == NULL) {
printf("无法打开文件: %s\n", filename);
return -1;
}
long long word_count = 0;
char buffer[BUFFER_SIZE];
size_t bytes_read;
printf("开始处理大文件: %s\n", filename);
printf("查找单词: %s\n", target_word);
printf("缓冲区大小: %d字节\n\n", BUFFER_SIZE);
// 用于跟踪跨缓冲区的单词
char partial_word[256] = "";
int partial_len = 0;
// 分批读取文件
while ((bytes_read = fread(buffer, 1, BUFFER_SIZE, file)) > 0) {
int processed = 0;
while (processed < bytes_read) {
// 查找单词边界（空格、标点等）
int word_start = processed;
int word_end = word_start;
// 找到单词的开始（跳过非字母字符）
while (word_start < bytes_read &&
!((buffer[word_start] >= 'A' && buffer[word_start] <= 'Z') ||
(buffer[word_start] >= 'a' && buffer[word_start] <= 'z'))) {
word_start++;
}
if (word_start >= bytes_read) {
processed = bytes_read;
break;
}
// 找到单词的结束
word_end = word_start;
while (word_end < bytes_read &&
((buffer[word_end] >= 'A' && buffer[word_end] <= 'Z') ||
(buffer[word_end] >= 'a' && buffer[word_end] <= 'z'))) {
word_end++;
}
// 提取单词
int word_length = word_end - word_start;
// 如果单词跨越缓冲区边界
if (word_end == bytes_read && word_start < bytes_read) {
// 保存部分单词
memcpy(partial_word + partial_len, buffer + word_start, word_length);
partial_len += word_length;
processed = bytes_read;
break;
}
// 完整的单词
char word[256];
int current_word_len = 0;
// 如果有部分单词从前一个缓冲区来
if (partial_len > 0) {
memcpy(word, partial_word, partial_len);
current_word_len = partial_len;
partial_len = 0;
partial_word[0] = '\0';
}
// 添加当前单词部分
memcpy(word + current_word_len, buffer + word_start, word_length);
current_word_len += word_length;
word[current_word_len] = '\0';
// 比较单词（不区分大小写）
if (strcasecmp(word, target_word) == 0) {
word_count++;
}
processed = word_end;
}
// 显示进度
static long long total_bytes = 0;
total_bytes += bytes_read;
printf("已处理: %lld字节，找到单词 '%s' %lld次\r",
total_bytes, target_word, word_count);
fflush(stdout);
}
fclose(file);
printf("\n\n处理完成！\n");
return word_count;
}
int main() {
// 创建一个大文件用于测试
printf("创建测试文件...\n");
FILE *test_file = fopen("large_test.txt", "w");
if (test_file == NULL) {
printf("无法创建测试文件！\n");
return 1;
}
// 写入大量数据
const char *lorem_ipsum = "Lorem ipsum dolor sit amet consectetur adipiscing elit ";
for (int i = 0; i < 10000; i++) {
fprintf(test_file, "%s", lorem_ipsum);
if (i % 100 == 0) {
fprintf(test_file, "ipsum "); // 增加目标单词的出现频率
}
}
fclose(test_file);
printf("测试文件创建完成：large_test.txt\n\n");
// 统计单词出现次数
const char *target_word = "ipsum";
long long count = count_word_in_large_file("large_test.txt", target_word);
if (count >= 0) {
printf("单词 '%s' 在文件中出现了 %lld 次\n", target_word, count);
}
// 清理测试文件
remove("large_test.txt");
return 0;
}6. 备份和恢复
文件系统提供了数据备份和恢复的基础。通过复制文件，可以创建数据的备份副本，防止数据丢失。
c
// 示例：简单的文件备份工具
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
// 文件信息结构体
typedef struct {
char name[256];
long size;
time_t last_modified;
} FileInfo;
// 获取文件信息
int get_file_info(const char *filename, FileInfo *info) {
FILE *file = fopen(filename, "rb");
if (file == NULL) {
return 0; // 文件不存在或无法访问
}
strncpy(info->name, filename, sizeof(info->name) - 1);
info->name[sizeof(info->name) - 1] = '\0';
// 获取文件大小
fseek(file, 0, SEEK_END);
info->size = ftell(file);
rewind(file);
// 获取最后修改时间（简化处理）
info->last_modified = time(NULL);
fclose(file);
return 1;
}
// 备份单个文件
int backup_file(const char *source_path, const char *backup_dir) {
// 创建备份文件名（添加时间戳）
char backup_path[512];
time_t now = time(NULL);
struct tm *timeinfo = localtime(&now);
// 从源路径提取文件名
const char *filename = strrchr(source_path, '/');
if (filename == NULL) {
filename = strrchr(source_path, '\\');
}
if (filename == NULL) {
filename = source_path;
} else {
filename++; // 跳过路径分隔符
}
// 创建带时间戳的备份文件名
snprintf(backup_path, sizeof(backup_path),
"%s/%s.backup_%04d%02d%02d_%02d%02d%02d",
backup_dir, filename,
timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, timeinfo->tm_mday,
timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
// 打开源文件
FILE *source = fopen(source_path, "rb");
if (source == NULL) {
printf("错误：无法打开源文件 '%s'\n", source_path);
return 0;
}
// 创建备份文件
FILE *backup = fopen(backup_path, "wb");
if (backup == NULL) {
printf("错误：无法创建备份文件 '%s'\n", backup_path);
fclose(source);
return 0;
}
// 复制文件内容
char buffer[8192]; // 8KB缓冲区
size_t bytes_read;
long total_bytes = 0;
printf("备份文件: %s -> %s\n", source_path, backup_path);
while ((bytes_read = fread(buffer, 1, sizeof(buffer), source)) > 0) {
size_t bytes_written = fwrite(buffer, 1, bytes_read, backup);
if (bytes_written != bytes_read) {
printf("错误：写入备份文件失败\n");
fclose(source);
fclose(backup);
remove(backup_path); // 删除不完整的备份文件
return 0;
}
total_bytes += bytes_written;
// 显示进度
printf("已备份: %ld字节\r", total_bytes);
fflush(stdout);
}
fclose(source);
fclose(backup);
printf("\n备份完成！共备份 %ld 字节\n", total_bytes);
// 验证备份文件
FileInfo source_info, backup_info;
if (get_file_info(source_path, &source_info) &&
get_file_info(backup_path, &backup_info)) {
if (source_info.size == backup_info.size) {
printf("验证成功：源文件和备份文件大小一致\n");
return 1;
} else {
printf("警告：源文件和备份文件大小不一致\n");
return 0;
}
}
return 1;
}
// 恢复备份文件
int restore_backup(const char *backup_path, const char *restore_path) {
FILE *backup = fopen(backup_path, "rb");
if (backup == NULL) {
printf("错误：无法打开备份文件 '%s'\n", backup_path);
return 0;
}
FILE *restore = fopen(restore_path, "wb");
if (restore == NULL) {
printf("错误：无法创建恢复文件 '%s'\n", restore_path);
fclose(backup);
return 0;
}
// 复制文件内容
char buffer[8192];
size_t bytes_read;
long total_bytes = 0;
printf("恢复文件: %s -> %s\n", backup_path, restore_path);
while ((bytes_read = fread(buffer, 1, sizeof(buffer), backup)) > 0) {
size_t bytes_written = fwrite(buffer, 1, bytes_read, restore);
if (bytes_written != bytes_read) {
printf("错误：写入恢复文件失败\n");
fclose(backup);
fclose(restore);
return 0;
}
total_bytes += bytes_written;
printf("已恢复: %ld字节\r", total_bytes);
fflush(stdout);
}
fclose(backup);
fclose(restore);
printf("\n恢复完成！共恢复 %ld 字节\n", total_bytes);
return 1;
}
int main() {
int choice;
char source_path[256];
char backup_dir[256] = "./backups"; // 默认备份目录
printf("=== 简单文件备份工具 ===\n");
// 创建备份目录（如果不存在）
#ifdef _WIN32
system("mkdir backups 2>nul");
#else
system("mkdir -p backups");
#endif
do {
printf("\n请选择操作：\n");
printf("1. 备份文件\n");
printf("2. 恢复备份\n");
printf("3. 退出\n");
printf("选择: ");
scanf("%d", &choice);
getchar(); // 消耗换行符
switch (choice) {
case 1:
printf("请输入要备份的文件路径: ");
fgets(source_path, sizeof(source_path), stdin);
source_path[strcspn(source_path, "\n")] = '\0'; // 移除换行符
backup_file(source_path, backup_dir);
break;
case 2:
printf("请输入备份文件路径: ");
fgets(source_path, sizeof(source_path), stdin);
source_path[strcspn(source_path, "\n")] = '\0';
printf("请输入恢复路径: ");
char restore_path[256];
fgets(restore_path, sizeof(restore_path), stdin);
restore_path[strcspn(restore_path, "\n")] = '\0';
restore_backup(source_path, restore_path);
break;
case 3:
printf("退出程序。\n");
break;
default:
printf("无效的选择！\n");
break;
}
} while (choice != 3);
return 0;
}通过以上示例和解释，我们可以看到文件在计算机系统中的多种重要作用。掌握文件操作不仅能够帮助我们更好地管理和处理数据，还能够开发出更加强大和实用的应用程序。
二、数据文件
数据文件是专门用于存储程序数据的文件，与程序文件（源代码、可执行文件等）不同，数据文件主要包含程序运行时需要处理或生成的数据。在C语言中，数据文件可以分为文本文件和二进制文件两大类，每种类型都有其特定的用途和处理方式。
文本文件与二进制文件的对比
| 特性 | 文本文件 | 二进制文件 |
|---|---|---|
| 存储形式 | 字符序列，通常使用ASCII、UTF-8等编码 | 二进制数据，直接存储内存中的原始数据 |
| 可读性 | 人类可读，可用文本编辑器查看和编辑 | 人类不可读，需要特定程序解析 |
| 存储效率 | 较低，可能包含额外的格式字符（如换行符） | 较高，直接存储原始数据 |
| 平台兼容性 | 可能受换行符差异影响（\n vs \r\n） | 与平台无关，但可能受字节序影响 |
| 处理方式 | 按字符或行处理 | 按字节或数据结构处理 |
| 适用场景 | 配置文件、日志文件、源代码等 | 图像、音频、视频、数据库文件等 |
文本文件操作示例
c
// 示例：文本文件的读写操作
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 学生信息结构体
typedef struct {
int id;
char name[50];
int age;
float score;
} Student;
// 将学生信息保存为文本文件
int save_students_text(const char *filename, Student *students, int count) {
FILE *file = fopen(filename, "w");
if (file == NULL) {
printf("无法创建文件: %s\n", filename);
return 0;
}
// 写入表头
fprintf(file, "学号,姓名,年龄,成绩\n");
// 写入学生数据
for (int i = 0; i < count; i++) {
fprintf(file, "%d,%s,%d,%.2f\n",
students[i].id,
students[i].name,
students[i].age,
students[i].score);
}
fclose(file);
printf("已保存 %d 条学生记录到文本文件: %s\n", count, filename);
return 1;
}
// 从文本文件读取学生信息
int load_students_text(const char *filename, Student *students, int max_count) {
FILE *file = fopen(filename, "r");
if (file == NULL) {
printf("无法打开文件: %s\n", filename);
return 0;
}
char line[256];
int count = 0;
// 跳过表头
fgets(line, sizeof(line), file);
// 读取数据行
while (fgets(line, sizeof(line), file) != NULL && count < max_count) {
// 移除换行符
line[strcspn(line, "\n")] = '\0';
// 解析CSV格式的数据
char *token;
int field = 0;
token = strtok(line, ",");
while (token != NULL && field < 4) {
switch (field) {
case 0: // 学号
students[count].id = atoi(token);
break;
case 1: // 姓名
strncpy(students[count].name, token, sizeof(students[count].name) - 1);
students[count].name[sizeof(students[count].name) - 1] = '\0';
break;
case 2: // 年龄
students[count].age = atoi(token);
break;
case 3: // 成绩
students[count].score = atof(token);
break;
}
token = strtok(NULL, ",");
field++;
}
count++;
}
fclose(file);
printf("从文本文件加载了 %d 条学生记录\n", count);
return count;
}
// 显示学生信息
void display_students(Student *students, int count) {
printf("\n=== 学生信息 ===\n");
printf("%-8s %-20s %-6s %-6s\n", "学号", "姓名", "年龄", "成绩");
printf("----------------------------------------\n");
for (int i = 0; i < count; i++) {
printf("%-8d %-20s %-6d %-6.2f\n",
students[i].id,
students[i].name,
students[i].age,
students[i].score);
}
printf("========================================\n");
}
// 文本文件处理示例
void text_file_example() {
printf("\n=== 文本文件操作示例 ===\n");
// 创建测试数据
Student students[] = {
{1001, "张三", 20, 85.5},
{1002, "李四", 21, 92.0},
{1003, "王五", 19, 78.5},
{1004, "赵六", 22, 88.0},
{1005, "钱七", 20, 95.5}
};
int student_count = sizeof(students) / sizeof(students[0]);
// 显示原始数据
printf("原始学生数据：\n");
display_students(students, student_count);
// 保存为文本文件
if (save_students_text("students.csv", students, student_count)) {
printf("\n文本文件内容预览：\n");
printf("--------------------\n");
// 显示文件内容
FILE *file = fopen("students.csv", "r");
if (file != NULL) {
char line[256];
while (fgets(line, sizeof(line), file) != NULL) {
printf("%s", line);
}
fclose(file);
}
printf("--------------------\n");
// 从文本文件加载数据
Student loaded_students[10];
int loaded_count = load_students_text("students.csv", loaded_students, 10);
// 显示加载的数据
if (loaded_count > 0) {
printf("\n从文本文件加载的学生数据：\n");
display_students(loaded_students, loaded_count);
}
}
// 清理临时文件
remove("students.csv");
}二进制文件操作示例
c
// 示例：二进制文件的读写操作
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 将学生信息保存为二进制文件
int save_students_binary(const char *filename, Student *students, int count) {
FILE *file = fopen(filename, "wb");
if (file == NULL) {
printf("无法创建文件: %s\n", filename);
return 0;
}
// 写入记录数量
fwrite(&count, sizeof(int), 1, file);
// 写入学生数据
for (int i = 0; i < count; i++) {
fwrite(&students[i], sizeof(Student), 1, file);
}
fclose(file);
printf("已保存 %d 条学生记录到二进制文件: %s\n", count, filename);
// 显示文件大小
file = fopen(filename, "rb");
if (file != NULL) {
fseek(file, 0, SEEK_END);
long file_size = ftell(file);
fclose(file);
printf("文件大小: %ld字节\n", file_size);
}
return 1;
}
// 从二进制文件读取学生信息
int load_students_binary(const char *filename, Student *students, int max_count) {
FILE *file = fopen(filename, "rb");
if (file == NULL) {
printf("无法打开文件: %s\n", filename);
return 0;
}
// 读取记录数量
int count;
if (fread(&count, sizeof(int), 1, file) != 1) {
printf("读取记录数量失败\n");
fclose(file);
return 0;
}
// 限制读取的数量
if (count > max_count) {
printf("警告: 文件包含 %d 条记录，但最多只能读取 %d 条\n", count, max_count);
count = max_count;
}
// 读取学生数据
int records_read = 0;
for (int i = 0; i < count; i++) {
if (fread(&students[i], sizeof(Student), 1, file) == 1) {
records_read++;
} else {
break;
}
}
fclose(file);
printf("从二进制文件加载了 %d 条学生记录\n", records_read);
return records_read;
}
// 二进制文件处理示例
void binary_file_example() {
printf("\n=== 二进制文件操作示例 ===\n");
// 创建测试数据
Student students[] = {
{2001, "孙八", 21, 91.5},
{2002, "周九", 22, 87.0},
{2003, "吴十", 20, 79.5},
{2004, "郑十一", 23, 94.0},
{2005, "王十二", 19, 82.5}
};
int student_count = sizeof(students) / sizeof(students[0]);
// 显示原始数据
printf("原始学生数据：\n");
display_students(students, student_count);
// 保存为二进制文件
if (save_students_binary("students.dat", students, student_count)) {
// 从二进制文件加载数据
Student loaded_students[10];
int loaded_count = load_students_binary("students.dat", loaded_students, 10);
// 显示加载的数据
if (loaded_count > 0) {
printf("\n从二进制文件加载的学生数据：\n");
display_students(loaded_students, loaded_count);
}
// 显示二进制文件内容（十六进制格式）
printf("\n二进制文件内容（十六进制）：\n");
printf("偏移量 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\n");
printf("--------------------------------------------------------\n");
FILE *file = fopen("students.dat", "rb");
if (file != NULL) {
unsigned char buffer[16];
size_t bytes_read;
long offset = 0;
while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
printf("%08lX ", offset);
// 显示十六进制值
for (size_t i = 0; i < 16; i++) {
if (i < bytes_read) {
printf("%02X ", buffer[i]);
} else {
printf(" ");
}
if (i == 7) printf(" ");
}
printf(" ");
// 显示ASCII字符（可打印字符）
for (size_t i = 0; i < bytes_read; i++) {
if (buffer[i] >= 32 && buffer[i] <= 126) {
printf("%c", buffer[i]);
} else {
printf(".");
}
}
printf("\n");
offset += bytes_read;
}
fclose(file);
}
}
// 清理临时文件
remove("students.dat");
}
// 比较文本文件和二进制文件的差异
void compare_file_formats() {
printf("\n=== 文本文件与二进制文件比较 ===\n");
// 创建测试数据
Student test_student = {3001, "测试学生", 25, 99.5};
// 保存为文本文件
FILE *text_file = fopen("test_text.txt", "w");
if (text_file != NULL) {
fprintf(text_file, "%d,%s,%d,%.2f",
test_student.id,
test_student.name,
test_student.age,
test_student.score);
fclose(text_file);
// 获取文件大小
text_file = fopen("test_text.txt", "rb");
fseek(text_file, 0, SEEK_END);
long text_size = ftell(text_file);
fclose(text_file);
printf("文本文件大小: %ld字节\n", text_size);
}
// 保存为二进制文件
FILE *binary_file = fopen("test_binary.dat", "wb");
if (binary_file != NULL) {
fwrite(&test_student, sizeof(Student), 1, binary_file);
fclose(binary_file);
// 获取文件大小
binary_file = fopen("test_binary.dat", "rb");
fseek(binary_file, 0, SEEK_END);
long binary_size = ftell(binary_file);
fclose(binary_file);
printf("二进制文件大小: %ld字节\n", binary_size);
}
// 显示Student结构体的大小
printf("Student结构体大小: %zu字节\n", sizeof(Student));
// 清理临时文件
remove("test_text.txt");
remove("test_binary.dat");
}
int main() {
// 运行文本文件示例
text_file_example();
// 运行二进制文件示例
binary_file_example();
// 比较文件格式
compare_file_formats();
return 0;
}数据文件的编码问题
在处理文本文件时，字符编码是一个重要问题。不同的编码方式会影响文件的读取和显示。
c
// 示例：处理不同编码的文本文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
// 检测文件编码（简化版）
const char* detect_encoding(const char *filename) {
FILE *file = fopen(filename, "rb");
if (file == NULL) {
return "无法打开文件";
}
unsigned char buffer[4];
size_t bytes_read = fread(buffer, 1, 4, file);
fclose(file);
if (bytes_read >= 3) {
// 检查UTF-8 BOM
if (buffer[0] == 0xEF && buffer[1] == 0xBB && buffer[2] == 0xBF) {
return "UTF-8 with BOM";
}
// 检查UTF-16 LE BOM
if (buffer[0] == 0xFF && buffer[1] == 0xFE) {
return "UTF-16 LE";
}
// 检查UTF-16 BE BOM
if (buffer[0] == 0xFE && buffer[1] == 0xFF) {
return "UTF-16 BE";
}
// 检查UTF-32 LE BOM
if (bytes_read >= 4 && buffer[0] == 0xFF && buffer[1] == 0xFE &&
buffer[2] == 0x00 && buffer[3] == 0x00) {
return "UTF-32 LE";
}
// 检查UTF-32 BE BOM
if (bytes_read >= 4 && buffer[0] == 0x00 && buffer[1] == 0x00 &&
buffer[2] == 0xFE && buffer[3] == 0xFF) {
return "UTF-32 BE";
}
}
// 尝试判断是否为ASCII/UTF-8
file = fopen(filename, "rb");
if (file == NULL) {
return "未知";
}
int is_ascii = 1;
unsigned char ch;
while (fread(&ch, 1, 1, file) == 1) {
if (ch > 0x7F) { // 非ASCII字符
is_ascii = 0;
break;
}
}
fclose(file);
if (is_ascii) {
return "ASCII/UTF-8";
} else {
// 简单检测UTF-8有效性
file = fopen(filename, "rb");
int is_valid_utf8 = 1;
while (fread(&ch, 1, 1, file) == 1) {
if ((ch & 0x80) == 0) {
// 单字节字符 (0xxxxxxx)
continue;
} else if ((ch & 0xE0) == 0xC0) {
// 两字节字符 (110xxxxx)
if (fread(&ch, 1, 1, file) != 1 || (ch & 0xC0) != 0x80) {
is_valid_utf8 = 0;
break;
}
} else if ((ch & 0xF0) == 0xE0) {
// 三字节字符 (1110xxxx)
for (int i = 0; i < 2; i++) {
if (fread(&ch, 1, 1, file) != 1 || (ch & 0xC0) != 0x80) {
is_valid_utf8 = 0;
break;
}
}
} else if ((ch & 0xF8) == 0xF0) {
// 四字节字符 (11110xxx)
for (int i = 0; i < 3; i++) {
if (fread(&ch, 1, 1, file) != 1 || (ch & 0xC0) != 0x80) {
is_valid_utf8 = 0;
break;
}
}
} else {
is_valid_utf8 = 0;
break;
}
}
fclose(file);
if (is_valid_utf8) {
return "UTF-8 (无BOM)";
} else {
return "未知编码/二进制文件";
}
}
}
// 创建不同编码的测试文件
void create_test_files() {
printf("创建测试文件...\n");
// 1. ASCII文件
FILE *ascii_file = fopen("test_ascii.txt", "w");
if (ascii_file != NULL) {
fprintf(ascii_file, "This is an ASCII file.\n");
fprintf(ascii_file, "It contains only ASCII characters.\n");
fclose(ascii_file);
printf(" 创建: test_ascii.txt (ASCII)\n");
}
// 2. UTF-8文件（无BOM）
FILE *utf8_file = fopen("test_utf8.txt", "w");
if (utf8_file != NULL) {
fprintf(utf8_file, "这是一个UTF-8文件（无BOM）。\n");
fprintf(utf8_file, "This is a UTF-8 file (without BOM).\n");
fprintf(utf8_file, "包含中文和英文。Contains Chinese and English.\n");
fclose(utf8_file);
printf(" 创建: test_utf8.txt (UTF-8 without BOM)\n");
}
// 3. UTF-8文件（带BOM）
FILE *utf8_bom_file = fopen("test_utf8_bom.txt", "wb");
if (utf8_bom_file != NULL) {
// 写入UTF-8 BOM
unsigned char bom[] = {0xEF, 0xBB, 0xBF};
fwrite(bom, 1, 3, utf8_bom_file);
fprintf(utf8_bom_file, "这是一个UTF-8文件（带BOM）。\n");
fprintf(utf8_bom_file, "This is a UTF-8 file (with BOM).\n");
fclose(utf8_bom_file);
printf(" 创建: test_utf8_bom.txt (UTF-8 with BOM)\n");
}
// 4. 二进制文件
FILE *binary_file = fopen("test_binary.bin", "wb");
if (binary_file != NULL) {
unsigned char data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
fwrite(data, 1, sizeof(data), binary_file);
fclose(binary_file);
printf(" 创建: test_binary.bin (二进制文件)\n");
}
}
// 显示文件内容（尝试不同编码）
void display_file_content(const char *filename) {
printf("\n文件: %s\n", filename);
printf("检测到的编码: %s\n", detect_encoding(filename));
printf("内容预览:\n");
printf("----------------------------------------\n");
FILE *file = fopen(filename, "rb");
if (file == NULL) {
printf("无法打开文件\n");
return;
}
// 读取并显示前200个字节
unsigned char buffer[201];
size_t bytes_read = fread(buffer, 1, 200, file);
buffer[bytes_read] = '\0';
// 以十六进制和文本形式显示
for (size_t i = 0; i < bytes_read; i++) {
if (i % 16 == 0) {
printf("\n%04zX: ", i);
}
printf("%02X ", buffer[i]);
if (i % 16 == 7) {
printf(" ");
}
}
printf("\n\n文本表示:\n");
// 尝试以文本形式显示
for (size_t i = 0; i < bytes_read; i++) {
if (buffer[i] >= 32 && buffer[i] <= 126) {
printf("%c", buffer[i]);
} else if (buffer[i] == '\n') {
printf("\\n");
} else if (buffer[i] == '\r') {
printf("\\r");
} else if (buffer[i] == '\t') {
printf("\\t");
} else {
printf(".");
}
}
printf("\n----------------------------------------\n");
fclose(file);
}
int main() {
// 设置本地化（支持中文显示）
setlocale(LC_ALL, "");
printf("=== 文件编码检测示例 ===\n");
// 创建测试文件
create_test_files();
// 检测并显示每个文件的编码和内容
display_file_content("test_ascii.txt");
display_file_content("test_utf8.txt");
display_file_content("test_utf8_bom.txt");
display_file_content("test_binary.bin");
// 清理测试文件
remove("test_ascii.txt");
remove("test_utf8.txt");
remove("test_utf8_bom.txt");
remove("test_binary.bin");
printf("\n所有测试文件已清理。\n");
return 0;
}通过以上示例，我们可以看到数据文件在C语言编程中的重要性。无论是文本文件还是二进制文件，都有其特定的应用场景和处理方式。理解这些差异并根据实际需求选择合适的文件类型，是进行有效文件操作的关键。
三、文件的打开与关闭
在C语言中，文件操作通常遵循"打开-操作-关闭"的模式。这一模式确保了文件资源的正确管理和系统资源的有效利用。文件的打开和关闭是文件操作中最基础也是最重要的两个步骤，任何文件操作都必须从打开文件开始，以关闭文件结束。
3.1 流和标准流
流的概念
在C语言中，流（Stream）是一个抽象的概念，它代表了一种数据流动的方式。流可以被看作是一个数据序列，数据可以从源头流向目的地。在文件操作中，流是连接程序和文件的桥梁。
流的主要特点：
- 抽象性：流隐藏了底层设备的细节，为程序提供了统一的接口。
- 方向性：输入流用于读取数据，输出流用于写入数据。
- 缓冲机制：流通常具有缓冲区，可以提高I/O操作的效率。
标准流
C语言预定义了三个标准流，它们在程序启动时自动打开，在程序结束时自动关闭：
- 标准输入流（stdin）：用于从标准输入设备（通常是键盘）读取数据。
- 标准输出流（stdout）：用于向标准输出设备（通常是显示器）写入数据。
- 标准错误流（stderr）：用于输出错误信息，通常也输出到显示器。
这些标准流是FILE类型的指针，定义在<stdio.h>头文件中。
c
// 示例：标准流的使用
#include <stdio.h>
#include <ctype.h>
// 演示标准输入输出流
void standard_streams_demo() {
printf("=== 标准流演示 ===\n");
// 1. 标准输入(stdin)和标准输出(stdout)
printf("请输入一些文本（按Ctrl+Z结束输入）:\n");
int ch;
int char_count = 0;
int line_count = 0;
// 从stdin读取字符，统计字符和行数
while ((ch = getchar()) != EOF) {
putchar(ch); // 输出到stdout
char_count++;
if (ch == '\n') {
line_count++;
}
}
printf("\n\n统计结果：\n");
printf(" 字符数：%d\n", char_count);
printf(" 行数：%d\n", line_count);
// 2. 标准错误(stderr) - 通常用于错误信息
fprintf(stderr, "\n这是一个错误信息示例（输出到stderr）\n");
// 3. 清空输入缓冲区
printf("\n按任意键继续...");
while (getchar() != '\n'); // 清空输入缓冲区
}
// 重定向演示
void redirection_demo() {
printf("\n=== 流重定向演示 ===\n");
printf("本程序演示了标准流的重定向概念。\n");
printf("在命令行中，您可以使用以下命令重定向：\n");
printf(" program.exe < input.txt # 从文件读取输入\n");
printf(" program.exe > output.txt # 输出到文件\n");
printf(" program.exe 2> error.log # 错误信息输出到文件\n");
printf("\n当前程序的输出：\n");
// 演示同时使用stdout和stderr
printf("这是普通输出（stdout）\n");
fprintf(stderr, "这是错误输出（stderr）\n");
printf("\n注意：在重定向时，stdout和stderr可以分别重定向到不同的文件。\n");
}
// 缓冲机制演示
void buffering_demo() {
printf("\n=== 流缓冲机制演示 ===\n");
// 1. 全缓冲（通常用于文件）
printf("文件流通常使用全缓冲：\n");
FILE *file = fopen("buffer_test.txt", "w");
if (file != NULL) {
fprintf(file, "这行文字");
printf("已写入文件但尚未刷新缓冲区...\n");
printf("检查文件，内容可能还未写入磁盘。\n");
// 刷新缓冲区
fflush(file);
printf("已刷新缓冲区，内容现在应该写入磁盘了。\n");
fclose(file);
}
// 2. 行缓冲（通常用于终端）
printf("\n终端输出通常使用行缓冲：\n");
printf("这句话后面没有换行符");
// 由于没有换行符，可能不会立即显示
// 添加以下代码强制刷新
fflush(stdout);
// 等待用户按键
printf("\n按Enter键继续...");
getchar();
printf("现在这句话会立即显示，因为它以换行符结束。\n");
// 3. 无缓冲（stderr通常无缓冲）
printf("\n标准错误(stderr)通常无缓冲：\n");
fprintf(stderr, "错误信息立即显示，无需刷新\n");
// 清理临时文件
remove("buffer_test.txt");
}
// 流的属性查询
void stream_properties() {
printf("\n=== 标准流属性 ===\n");
// 检查标准流是否指向终端
printf("stdin 指向终端: %s\n", isatty(fileno(stdin)) ? "是" : "否");
printf("stdout 指向终端: %s\n", isatty(fileno(stdout)) ? "是" : "否");
printf("stderr 指向终端: %s\n", isatty(fileno(stderr)) ? "是" : "否");
// 获取文件描述符
printf("\n文件描述符：\n");
printf(" stdin 文件描述符: %d\n", fileno(stdin));
printf(" stdout 文件描述符: %d\n", fileno(stdout));
printf(" stderr 文件描述符: %d\n", fileno(stderr));
// 检查错误标志
printf("\n错误标志：\n");
printf(" stdin 错误标志: %s\n", ferror(stdin) ? "已设置" : "未设置");
printf(" stdout 错误标志: %s\n", ferror(stdout) ? "已设置" : "未设置");
printf(" stderr 错误标志: %s\n", ferror(stderr) ? "已设置" : "未设置");
// 清除错误标志
clearerr(stdin);
clearerr(stdout);
clearerr(stderr);
}
int main() {
printf("C语言标准流演示程序\n");
printf("===================\n");
// 演示标准流
standard_streams_demo();
// 演示重定向
redirection_demo();
// 演示缓冲机制
buffering_demo();
// 显示流属性
stream_properties();
printf("\n程序结束。\n");
return 0;
}3.2 文件指针
在C语言中，文件指针是指向FILE结构体的指针，它是进行文件操作的关键。FILE结构体定义在<stdio.h>头文件中，包含了管理文件流所需的所有信息，如文件位置指示器、错误指示器、缓冲区信息等。
FILE结构体的重要性
FILE结构体封装了文件操作的所有细节，包括：
- 文件描述符：操作系统标识文件的整数值
- 缓冲区信息：输入/输出缓冲区的位置和大小
- 位置指示器：当前读写位置
- 错误指示器：记录文件操作中发生的错误
- 文件状态标志：记录文件的打开模式等信息
文件指针的操作
c
// 示例：文件指针的深入理解
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 显示FILE结构体信息（平台相关，这里只显示部分通用信息）
void display_file_info(FILE *stream, const char *stream_name) {
printf("\n=== %s 的信息 ===\n", stream_name);
if (stream == NULL) {
printf(" 文件指针为NULL\n");
return;
}
// 获取文件描述符
int fd = fileno(stream);
printf(" 文件描述符: %d\n", fd);
// 检查错误标志
printf(" 错误标志: %s\n", ferror(stream) ? "已设置" : "未设置");
// 检查文件结束标志
printf(" 文件结束标志: %s\n", feof(stream) ? "已设置" : "未设置");
// 获取当前文件位置
long position = ftell(stream);
printf(" 当前位置: %ld\n", position);
// 检查流是否指向终端
printf(" 指向终端: %s\n", isatty(fd) ? "是" : "否");
}
// 演示文件指针的复制和独立操作
void file_pointer_copy_demo() {
printf("\n=== 文件指针复制演示 ===\n");
// 创建一个测试文件
FILE *original = fopen("test_pointer.txt", "w+");
if (original == NULL) {
printf("无法创建测试文件\n");
return;
}
// 写入一些数据
fprintf(original, "第1行: Hello World\n");
fprintf(original, "第2行: File Pointer Demo\n");
fprintf(original, "第3行: Testing\n");
// 显示原始指针信息
display_file_info(original, "原始指针");
// "复制"文件指针（实际上是复制指针值，指向同一个FILE结构体）
FILE *copy = original;
printf("\n复制指针后：\n");
printf("原始指针地址: %p\n", (void*)original);
printf("复制指针地址: %p\n", (void*)copy);
printf("两个指针相等: %s\n", original == copy ? "是" : "否");
// 通过复制指针写入数据
fprintf(copy, "第4行: Via Copy Pointer\n");
// 回到文件开头
rewind(original);
// 通过原始指针读取数据
printf("\n文件内容：\n");
char line[100];
while (fgets(line, sizeof(line), original) != NULL) {
printf(" %s", line);
}
// 注意：两个指针共享同一个文件位置
printf("\n当前位置：\n");
printf("原始指针位置: %ld\n", ftell(original));
printf("复制指针位置: %ld\n", ftell(copy));
// 关闭文件（只需要关闭一次）
fclose(original);
// 注意：不要再次关闭copy，因为它指向同一个FILE结构体
// 清理测试文件
remove("test_pointer.txt");
}
// 演示多个独立的文件指针操作同一个文件
void multiple_pointers_demo() {
printf("\n=== 多个独立文件指针演示 ===\n");
// 创建测试文件
FILE *file1 = fopen("test_multi.txt", "w");
if (file1 != NULL) {
fprintf(file1, "初始内容\n");
fclose(file1);
}
// 以不同模式打开同一个文件
FILE *read_stream = fopen("test_multi.txt", "r");
FILE *write_stream = fopen("test_multi.txt", "a"); // 追加模式
if (read_stream == NULL || write_stream == NULL) {
printf("无法打开文件\n");
return;
}
printf("读取流地址: %p\n", (void*)read_stream);
printf("写入流地址: %p\n", (void*)write_stream);
// 通过写入流添加内容
fprintf(write_stream, "追加的内容1\n");
fflush(write_stream); // 确保写入磁盘
// 通过读取流读取内容
printf("\n读取流读取的内容：\n");
rewind(read_stream);
char buffer[100];
while (fgets(buffer, sizeof(buffer), read_stream) != NULL) {
printf(" %s", buffer);
}
// 再次追加内容
fprintf(write_stream, "追加的内容2\n");
// 由于读取流有缓冲区，可能看不到最新内容
// 需要清除读取流的缓冲区或重新打开
printf("\n注意：读取流可能看不到最新追加的内容\n");
printf("因为每个文件流有自己的缓冲区。\n");
// 关闭文件流
fclose(read_stream);
fclose(write_stream);
// 清理测试文件
remove("test_multi.txt");
}
// 演示文件指针数组
void file_pointer_array_demo() {
printf("\n=== 文件指针数组演示 ===\n");
// 创建多个临时文件
const char *filenames[] = {"temp1.txt", "temp2.txt", "temp3.txt"};
const int file_count = sizeof(filenames) / sizeof(filenames[0]);
FILE *files[file_count];
// 打开所有文件
for (int i = 0; i < file_count; i++) {
files[i] = fopen(filenames[i], "w");
if (files[i] != NULL) {
fprintf(files[i], "这是文件 %d 的内容\n", i + 1);
printf("已创建文件: %s (指针: %p)\n",
filenames[i], (void*)files[i]);
}
}
// 在所有文件中追加内容
for (int i = 0; i < file_count; i++) {
if (files[i] != NULL) {
fprintf(files[i], "追加的行: 文件索引 %d\n", i);
}
}
// 关闭所有文件
for (int i = 0; i < file_count; i++) {
if (files[i] != NULL) {
fclose(files[i]);
}
}
// 重新打开并显示所有文件内容
printf("\n所有文件的内容：\n");
for (int i = 0; i < file_count; i++) {
files[i] = fopen(filenames[i], "r");
if (files[i] != NULL) {
printf("\n%s:\n", filenames[i]);
char line[100];
while (fgets(line, sizeof(line), files[i]) != NULL) {
printf(" %s", line);
}
fclose(files[i]);
}
}
// 清理临时文件
for (int i = 0; i < file_count; i++) {
remove(filenames[i]);
}
}
// 错误处理：无效文件指针
void invalid_pointer_demo() {
printf("\n=== 无效文件指针处理 ===\n");
FILE *invalid_ptr = NULL;
// 测试1: 对NULL指针进行操作
printf("测试1: 对NULL指针进行fprintf\n");
int result = fprintf(invalid_ptr, "这应该失败");
printf(" fprintf返回值: %d\n", result);
printf(" 错误信息: ");
perror("fprintf");
// 测试2: 使用已关闭的文件指针
printf("\n测试2: 使用已关闭的文件指针\n");
FILE *temp = fopen("temp.txt", "w");
if (temp != NULL) {
fprintf(temp, "测试内容\n");
fclose(temp);
// 尝试使用已关闭的指针
result = fprintf(temp, "这应该失败");
printf(" fprintf返回值: %d\n", result);
// 检查错误标志
printf(" 错误标志: %s\n", ferror(temp) ? "已设置" : "未设置");
remove("temp.txt");
}
// 测试3: 使用未初始化的指针
printf("\n测试3: 使用未初始化的指针\n");
FILE *uninitialized;
// 警告：未初始化的指针包含随机值
// 以下操作可能导致程序崩溃
// result = fprintf(uninitialized, "危险操作");
// printf(" 这行代码被注释掉了，因为它是危险的\n");
printf("\n最佳实践：\n");
printf("1. 总是检查fopen的返回值是否为NULL\n");
printf("2. 不要重复关闭同一个文件指针\n");
printf("3. 在关闭文件指针后将其设为NULL\n");
printf("4. 避免使用未初始化的文件指针\n");
}
int main() {
printf("文件指针深入理解演示程序\n");
printf("=======================\n");
// 演示文件指针复制
file_pointer_copy_demo();
// 演示多个文件指针
multiple_pointers_demo();
// 演示文件指针数组
file_pointer_array_demo();
// 演示无效指针处理
invalid_pointer_demo();
printf("\n程序结束。\n");
return 0;
}3.3 文件的打开(fopen函数)
fopen函数是C语言中用于打开文件的核心函数，它负责建立程序与文件之间的连接，并返回一个文件指针供后续操作使用。
(1) fopen函数简介
函数原型：
c
FILE *fopen(const char *filename, const char *mode);参数说明：
filename：要打开的文件的路径和名称mode：文件的打开模式，指定了文件的访问方式
返回值：
- 成功：返回指向FILE结构体的指针
- 失败：返回NULL指针
(2) filename（要打开的文件名）
filename参数是一个字符串，指定了要打开的文件的路径。这个路径可以是绝对路径，也可以是相对路径。
c
// 示例：filename参数的各种形式
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void filename_demo() {
printf("=== filename参数演示 ===\n");
// 各种文件路径示例
const char *filenames[] = {
// 相对路径
"test.txt", // 当前目录下的文件
"./test.txt", // 当前目录下的文件（显式）
"../parent/test.txt", // 父目录下的文件
"data/files/test.txt", // 子目录下的文件
// 绝对路径（平台相关）
#ifdef _WIN32
"C:\\Users\\test\\file.txt", // Windows绝对路径
"C:/Users/test/file.txt", // Windows绝对路径（使用正斜杠）
#else
"/home/user/test/file.txt", // Linux/Unix绝对路径
#endif
// 特殊文件名
".hidden", // 隐藏文件（Unix/Linux）
"file with spaces.txt", // 包含空格的文件名
"file\\(special\\).txt", // 包含特殊字符的文件名
};
const int count = sizeof(filenames) / sizeof(filenames[0]);
printf("各种文件路径示例：\n");
for (int i = 0; i < count; i++) {
printf(" %2d. %s\n", i + 1, filenames[i]);
}
// 创建和测试一些文件路径
printf("\n创建和测试文件路径：\n");
// 1. 简单文件名
FILE *simple = fopen("simple_test.txt", "w");
if (simple != NULL) {
fprintf(simple, "这是一个测试文件\n");
fclose(simple);
printf(" 已创建: simple_test.txt\n");
}
// 2. 带有目录的文件名（需要创建目录）
#ifdef _WIN32
system("mkdir test_dir 2>nul");
#else
system("mkdir -p test_dir");
#endif
FILE *dir_file = fopen("test_dir/subfile.txt", "w");
if (dir_file != NULL) {
fprintf(dir_file, "子目录中的文件\n");
fclose(dir_file);
printf(" 已创建: test_dir/subfile.txt\n");
}
// 3. 包含特殊字符的文件名
FILE *special = fopen("special_test_file.txt", "w");
if (special != NULL) {
fprintf(special, "文件名包含特殊字符测试\n");
fclose(special);
printf(" 已创建: special_test_file.txt\n");
}
// 4. 测试文件路径长度限制
printf("\n文件路径长度测试：\n");
// 创建一个长文件名
char long_filename[300] = "very_long_filename_";
for (int i = 0; i < 20; i++) {
strcat(long_filename, "1234567890");
}
strcat(long_filename, ".txt");
FILE *long_file = fopen(long_filename, "w");
if (long_file != NULL) {
fprintf(long_file, "这是一个具有很长文件名的测试文件\n");
fclose(long_file);
printf(" 已创建长文件名文件（长度：%zu）\n", strlen(long_filename));
// 显示前50个字符
printf(" 文件名预览: %.50s...\n", long_filename);
} else {
printf(" 创建长文件名文件失败（可能超过系统限制）\n");
}
// 测试不存在的目录
printf("\n测试不存在的目录：\n");
FILE *nonexistent = fopen("nonexistent_dir/file.txt", "w");
if (nonexistent == NULL) {
printf(" 打开失败（预期中）：");
perror("fopen");
} else {
fclose(nonexistent);
printf(" 意外成功：创建了不存在的目录中的文件\n");
}
// 清理测试文件
printf("\n清理测试文件...\n");
remove("simple_test.txt");
remove("test_dir/subfile.txt");
#ifdef _WIN32
system("rmdir test_dir");
#else
system("rm -rf test_dir");
#endif
remove("special_test_file.txt");
if (long_file != NULL) {
remove(long_filename);
}
printf("\n文件路径处理的最佳实践：\n");
printf("1. 使用相对路径以提高可移植性\n");
printf("2. 避免在文件名中使用特殊字符\n");
printf("3. 考虑文件路径长度限制\n");
printf("4. 检查目录是否存在，或使用适当错误处理\n");
printf("5. 在Windows和Unix之间移植时注意路径分隔符差异\n");
}
// 跨平台路径处理
void cross_platform_paths() {
printf("\n=== 跨平台路径处理 ===\n");
// 定义路径分隔符
#ifdef _WIN32
const char PATH_SEPARATOR = '\\';
const char *PATH_SEPARATOR_STR = "\\";
#else
const char PATH_SEPARATOR = '/';
const char *PATH_SEPARATOR_STR = "/";
#endif
printf("当前平台路径分隔符: '%c'\n", PATH_SEPARATOR);
// 构建跨平台路径的几种方法
// 方法1: 使用平台特定的分隔符
char path1[256];
snprintf(path1, sizeof(path1), "data%cfile.txt", PATH_SEPARATOR);
printf("方法1路径: %s\n", path1);
// 方法2: 总是使用正斜杠（在大多数平台上都有效）
const char *path2 = "data/file.txt";
printf("方法2路径: %s\n", path2);
// 方法3: 使用条件编译
char path3[256];
#ifdef _WIN32
strcpy(path3, "data\\subdir\\file.txt");
#else
strcpy(path3, "data/subdir/file.txt");
#endif
printf("方法3路径: %s\n", path3);
// 方法4: 使用宏定义
#define PATH_JOIN(dir, file) dir PATH_SEPARATOR_STR file
const char *path4 = PATH_JOIN("data", "file.txt");
printf("方法4路径: %s\n", path4);
// 演示文件操作
FILE *test_file = fopen(path2, "w");
if (test_file != NULL) {
fprintf(test_file, "跨平台路径测试\n");
fclose(test_file);
printf("已使用跨平台路径创建文件\n");
// 清理
remove(path2);
}
printf("\n路径处理建议：\n");
printf("1. 对于简单程序，使用正斜杠通常足够\n");
printf("2. 对于复杂项目，考虑使用平台特定的路径处理函数\n");
printf("3. 使用相对路径而不是绝对路径\n");
printf("4. 考虑使用第三方库（如Boost.Filesystem）进行高级路径操作\n");
}
// 文件名验证和安全性
void filename_validation() {
printf("\n=== 文件名验证和安全性 ===\n");
// 潜在的危险文件名
const char *dangerous_names[] = {
"/etc/passwd", // 系统文件（Unix）
"C:\\Windows\\System32\\*", // 系统目录（Windows）
"../../../etc/passwd", // 目录遍历攻击
"file; rm -rf /;", // 命令注入
"file\n<script>alert('xss')</script>", // 注入攻击
"con", "prn", "aux", "nul", // 保留设备名（Windows）
"COM1", "LPT1", // 保留设备名（Windows）
};
printf("潜在的危险文件名示例：\n");
for (int i = 0; i < sizeof(dangerous_names) / sizeof(dangerous_names[0]); i++) {
printf(" %2d. %s\n", i + 1, dangerous_names[i]);
}
// 文件名验证函数
printf("\n文件名验证演示：\n");
const char *test_names[] = {
"safe_file.txt",
"unsafe/../file.txt",
"../../etc/passwd",
"file with spaces.txt",
"file<>.txt",
"CON", // Windows保留名
};
for (int i = 0; i < sizeof(test_names) / sizeof(test_names[0]); i++) {
const char *name = test_names[i];
int is_safe = 1;
// 简单验证规则
if (strstr(name, "..") != NULL) {
is_safe = 0; // 包含目录遍历
}
if (strchr(name, '/') != NULL || strchr(name, '\\') != NULL) {
is_safe = 0; // 包含路径分隔符
}
// Windows保留名检查（简化版）
#ifdef _WIN32
const char *reserved_names[] = {"CON", "PRN", "AUX", "NUL",
"COM1", "COM2", "LPT1", "LPT2"};
for (int j = 0; j < sizeof(reserved_names) / sizeof(reserved_names[0]); j++) {
if (strcasecmp(name, reserved_names[j]) == 0) {
is_safe = 0;
break;
}
}
#endif
printf(" '%s': %s\n", name, is_safe ? "安全" : "不安全");
}
printf("\n文件名安全建议：\n");
printf("1. 验证用户输入的文件名\n");
printf("2. 防止目录遍历攻击（检查'..'）\n");
printf("3. 限制文件名中的特殊字符\n");
printf("4. 注意平台特定的保留名\n");
printf("5. 使用白名单而不是黑名单进行验证\n");
}
int main() {
printf("文件名和路径处理演示\n");
printf("====================\n");
filename_demo();
cross_platform_paths();
filename_validation();
printf("\n程序结束。\n");
return 0;
}(3) mode（文件打开方式）
mode参数是一个字符串，指定了文件的打开模式。不同的模式决定了文件如何被访问，以及文件指针的初始位置。
基本打开模式：
| 模式 | 描述 | 文件必须存在？ | 文件被截断？ | 初始位置 | 常见用途 |
|---|---|---|---|---|---|
| "r" | 只读模式 | 是 | 否 | 文件开头 | 读取现有文件 |
| "w" | 只写模式 | 否 | 是 | 文件开头 | 创建新文件或覆盖现有文件 |
| "a" | 追加模式 | 否 | 否 | 文件末尾 | 向文件末尾添加数据 |
| "r+" | 读写模式 | 是 | 否 | 文件开头 | 读取和修改现有文件 |
| "w+" | 读写模式 | 否 | 是 | 文件开头 | 创建新文件或覆盖现有文件，然后读写 |
| "a+" | 读写模式 | 否 | 否 | 文件末尾 | 读取和向文件末尾添加数据 |
二进制模式：
在以上模式后添加"b"表示二进制模式，如"rb"、"wb"、"ab"等。
c
// 示例：文件打开模式详解
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 创建测试文件
void create_test_file(const char *filename, const char *content) {
FILE *file = fopen(filename, "w");
if (file != NULL) {
fprintf(file, "%s", content);
fclose(file);
}
}
// 演示各种打开模式
void open_modes_demo() {
printf("=== 文件打开模式演示 ===\n");
const char *test_content = "原始文件内容\n第二行\n";
const char *test_filename = "mode_test.txt";
// 1. 只读模式 ("r")
printf("\n1. 只读模式 (\"r\"):\n");
create_test_file(test_filename, test_content);
FILE *file_r = fopen(test_filename, "r");
if (file_r != NULL) {
printf(" 文件打开成功\n");
// 读取文件内容
char buffer[100];
printf(" 文件内容：\n");
while (fgets(buffer, sizeof(buffer), file_r) != NULL) {
printf(" %s", buffer);
}
// 尝试写入（应该失败）
int write_result = fprintf(file_r, "尝试写入\n");
printf(" 写入尝试结果: %d (负数表示失败)\n", write_result);
fclose(file_r);
} else {
printf(" 文件打开失败\n");
}
// 2. 只写模式 ("w")
printf("\n2. 只写模式 (\"w\"):\n");
FILE *file_w = fopen(test_filename, "w");
if (file_w != NULL) {
printf(" 文件打开成功\n");
printf(" 注意：文件被截断（清空）\n");
// 写入新内容
fprintf(file_w, "新内容（覆盖原内容）\n");
fclose(file_w);
// 验证内容
file_r = fopen(test_filename, "r");
if (file_r != NULL) {
char buffer[100];
printf(" 当前文件内容：\n");
while (fgets(buffer, sizeof(buffer), file_r) != NULL) {
printf(" %s", buffer);
}
fclose(file_r);
}
}
// 3. 追加模式 ("a")
printf("\n3. 追加模式 (\"a\"):\n");
FILE *file_a = fopen(test_filename, "a");
if (file_a != NULL) {
printf(" 文件打开成功\n");
printf(" 文件指针初始位置: %ld\n", ftell(file_a));
// 追加内容
fprintf(file_a, "追加的内容\n");
fclose(file_a);
// 验证内容
file_r = fopen(test_filename, "r");
if (file_r != NULL) {
char buffer[100];
printf(" 当前文件内容：\n");
while (fgets(buffer, sizeof(buffer), file_r) != NULL) {
printf(" %s", buffer);
}
fclose(file_r);
}
}
// 4. 读写模式 ("r+")
printf("\n4. 读写模式 (\"r+\"):\n");
// 先重置文件内容
create_test_file(test_filename, "第1行: ABC\n第2行: DEF\n第3行: GHI\n");
FILE *file_rp = fopen(test_filename, "r+");
if (file_rp != NULL) {
printf(" 文件打开成功\n");
printf(" 初始位置: %ld\n", ftell(file_rp));
// 读取第一行
char line[100];
fgets(line, sizeof(line), file_rp);
printf(" 读取的第一行: %s", line);
printf(" 读取后位置: %ld\n", ftell(file_rp));
// 回到文件开头并修改
fseek(file_rp, 0, SEEK_SET);
fprintf(file_rp, "修改的第一行: XYZ\n");
// 显示最终内容
rewind(file_rp);
printf(" 最终文件内容：\n");
while (fgets(line, sizeof(line), file_rp) != NULL) {
printf(" %s", line);
}
fclose(file_rp);
}
// 5. 读写模式 ("w+")
printf("\n5. 读写模式 (\"w+\"):\n");
FILE *file_wp = fopen(test_filename, "w+");
if (file_wp != NULL) {
printf(" 文件打开成功\n");
printf(" 注意：文件被截断（清空）\n");
printf(" 初始位置: %ld\n", ftell(file_wp));
// 写入内容
fprintf(file_wp, "新文件内容\n");
// 读取刚才写入的内容
rewind(file_wp);
char line[100];
fgets(line, sizeof(line), file_wp);
printf(" 读取的内容: %s", line);
fclose(file_wp);
}
// 6. 读写模式 ("a+")
printf("\n6. 读写模式 (\"a+\"):\n");
// 先重置文件内容
create_test_file(test_filename, "原始内容\n");
FILE *file_ap = fopen(test_filename, "a+");
if (file_ap != NULL) {
printf(" 文件打开成功\n");
printf(" 初始位置（应在文件末尾）: %ld\n", ftell(file_ap));
// 追加内容
fprintf(file_ap, "追加的内容\n");
// 读取整个文件（需要回到开头）
rewind(file_ap);
printf(" 文件内容：\n");
char line[100];
while (fgets(line, sizeof(line), file_ap) != NULL) {
printf(" %s", line);
}
fclose(file_ap);
}
// 清理测试文件
remove(test_filename);
}
// 二进制模式演示
void binary_mode_demo() {
printf("\n=== 二进制模式演示 ===\n");
const char *binary_filename = "binary_test.bin";
// 写入二进制数据
printf("1. 写入二进制数据\n");
FILE *write_binary = fopen(binary_filename, "wb");
if (write_binary != NULL) {
int numbers[] = {10, 20, 30, 40, 50};
float pi = 3.14159;
char message[] = "Hello Binary";
fwrite(numbers, sizeof(int), 5, write_binary);
fwrite(&pi, sizeof(float), 1, write_binary);
fwrite(message, sizeof(char), strlen(message) + 1, write_binary); // 包含空字符
fclose(write_binary);
printf(" 已写入二进制文件\n");
}
// 读取二进制数据
printf("\n2. 读取二进制数据\n");
FILE *read_binary = fopen(binary_filename, "rb");
if (read_binary != NULL) {
int numbers[5];
float pi;
char message[50];
fread(numbers, sizeof(int), 5, read_binary);
fread(&pi, sizeof(float), 1, read_binary);
fread(message, sizeof(char), sizeof(message), read_binary);
printf(" 读取的数据：\n");
printf(" 整数: ");
for (int i = 0; i < 5; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
printf(" 浮点数: %.5f\n", pi);
printf(" 字符串: %s\n", message);
fclose(read_binary);
}
// 文本模式与二进制模式的差异
printf("\n3. 文本模式与二进制模式差异\n");
const char *text_filename = "text_test.txt";
// 用文本模式写入
FILE *text_write = fopen(text_filename, "w");
if (text_write != NULL) {
fprintf(text_write, "Line1\nLine2\n");
fclose(text_write);
}
// 用二进制模式读取文本文件
FILE *binary_read = fopen(text_filename, "rb");
if (binary_read != NULL) {
printf(" 二进制模式读取文本文件：\n");
unsigned char buffer[100];
size_t bytes = fread(buffer, 1, sizeof(buffer), binary_read);
printf(" 字节数: %zu\n", bytes);
printf(" 十六进制: ");
for (size_t i = 0; i < bytes; i++) {
printf("%02X ", buffer[i]);
}
printf("\n");
fclose(binary_read);
}
// 清理文件
remove(binary_filename);
remove(text_filename);
}
// 模式组合和高级用法
void advanced_modes() {
printf("\n=== 高级打开模式 ===\n");
const char *filename = "advanced_test.txt";
// 1. 同时使用读写模式
printf("1. 使用r+模式进行随机访问\n");
create_test_file(filename, "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n");
FILE *file = fopen(filename, "r+");
if (file != NULL) {
// 移动到第10个字节
fseek(file, 9, SEEK_SET);
// 修改第10个字符
fputc('*', file);
// 读取修改后的内容
rewind(file);
char buffer[100];
fgets(buffer, sizeof(buffer), file);
printf(" 修改后内容: %s", buffer);
fclose(file);
}
// 2. 使用a+模式读取历史数据
printf("\n2. 使用a+模式读取和追加\n");
file = fopen(filename, "a+");
if (file != NULL) {
// 当前位置在文件末尾
printf(" 初始位置: %ld\n", ftell(file));
// 读取整个文件（需要回到开头）
rewind(file);
printf(" 文件内容: ");
int ch;
while ((ch = fgetc(file)) != EOF) {
putchar(ch);
}
// 追加新内容
fprintf(file, "追加的新行\n");
fclose(file);
}
// 3. 创建不存在的文件（使用w或w+）
printf("\n3. 创建新文件\n");
remove(filename); // 确保文件不存在
file = fopen(filename, "w");
if (file != NULL) {
printf(" 新文件创建成功\n");
fprintf(file, "这是新文件的内容\n");
fclose(file);
}
// 4. 打开不存在的文件进行读取（应该失败）
printf("\n4. 尝试打开不存在的文件进行读取\n");
remove(filename); // 确保文件不存在
file = fopen(filename, "r");
if (file == NULL) {
printf(" 打开失败（预期中）\n");
perror(" fopen");
} else {
printf(" 意外成功\n");
fclose(file);
}
// 5. 独占打开（某些系统支持）
printf("\n5. 独占打开模式\n");
// 注意：标准C库不支持独占模式，但某些平台有扩展
// 清理
remove(filename);
printf("\n模式选择建议：\n");
printf("1. 只读取用\"r\"，只写入用\"w\"，追加用\"a\"\n");
printf("2. 需要同时读写时，根据需求选择\"r+\"、\"w+\"或\"a+\"\n");
printf("3. 处理二进制数据时总是使用二进制模式\n");
printf("4. 考虑文件不存在时的行为选择合适的模式\n");
}
int main() {
printf("文件打开模式详解演示\n");
printf("====================\n");
open_modes_demo();
binary_mode_demo();
advanced_modes();
printf("\n程序结束。\n");
return 0;
}(4) fopen的返回值
fopen函数的返回值是一个FILE指针，这个指针是后续所有文件操作的基础。正确理解和处理fopen的返回值对于编写健壮的文件操作代码至关重要。
c
// 示例：fopen返回值处理
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
// 错误处理宏
#define CHECK_NULL(ptr, msg) \
if ((ptr) == NULL) { \
fprintf(stderr, "错误: %s\n", (msg)); \
fprintf(stderr, "错误代码: %d\n", errno); \
fprintf(stderr, "错误信息: %s\n", strerror(errno)); \
return NULL; \
}
// 安全打开文件函数
FILE* safe_fopen(const char *filename, const char *mode, int *error_code) {
FILE *file = fopen(filename, mode);
if (file == NULL) {
*error_code = errno;
// 根据错误代码提供更具体的错误信息
switch (errno) {
case ENOENT:
fprintf(stderr, "文件不存在: %s\n", filename);
break;
case EACCES:
fprintf(stderr, "权限不足: %s\n", filename);
break;
case EMFILE:
fprintf(stderr, "打开文件过多\n");
break;
case ENOSPC:
fprintf(stderr, "磁盘空间不足\n");
break;
default:
fprintf(stderr, "无法打开文件: %s (错误: %s)\n",
filename, strerror(errno));
break;
}
} else {
*error_code = 0;
}
return file;
}
// 演示基本的返回值检查
void basic_return_check() {
printf("=== fopen基本返回值检查 ===\n");
const char *filename = "test_file.txt";
// 1. 成功的打开
printf("1. 成功打开文件：\n");
FILE *success_file = fopen(filename, "w");
if (success_file != NULL) {
printf(" 打开成功，文件指针: %p\n", (void*)success_file);
fprintf(success_file, "测试内容\n");
fclose(success_file);
}
// 2. 失败的打开
printf("\n2. 打开不存在的文件进行读取：\n");
FILE *fail_file = fopen("non_existent_file.txt", "r");
if (fail_file == NULL) {
printf(" 打开失败，返回NULL\n");
printf(" 错误代码: %d\n", errno);
printf(" 错误信息: %s\n", strerror(errno));
}
// 3. 权限问题（尝试打开目录）
printf("\n3. 尝试打开目录：\n");
FILE *dir_file = fopen(".", "r");
if (dir_file == NULL) {
printf(" 打开失败（预期中）\n");
printf(" 错误信息: %s\n", strerror(errno));
} else {
printf(" 意外成功\n");
fclose(dir_file);
}
// 清理
remove(filename);
}
// 演示错误处理的几种方法
void error_handling_methods() {
printf("\n=== fopen错误处理方法 ===\n");
// 方法1: 简单的错误处理
printf("方法1: 简单错误处理\n");
{
FILE *file = fopen("test1.txt", "w");
if (file == NULL) {
printf(" 无法打开文件\n");
// 可能需要退出程序或采取其他措施
} else {
fprintf(file, "测试\n");
fclose(file);
}
}
// 方法2: 使用perror
printf("\n方法2: 使用perror\n");
{
FILE *file = fopen("test2.txt", "w");
if (file == NULL) {
perror("fopen失败");
} else {
fprintf(file, "测试\n");
fclose(file);
}
}
// 方法3: 使用errno和strerror
printf("\n方法3: 使用errno和strerror\n");
{
FILE *file = fopen("test3.txt", "w");
if (file == NULL) {
fprintf(stderr, "错误代码: %d\n", errno);
fprintf(stderr, "错误信息: %s\n", strerror(errno));
} else {
fprintf(file, "测试\n");
fclose(file);
}
}
// 方法4: 封装错误处理
printf("\n方法4: 封装错误处理\n");
{
int error_code;
FILE *file = safe_fopen("test4.txt", "w", &error_code);
if (file != NULL) {
fprintf(file, "测试\n");
fclose(file);
printf(" 打开成功，错误代码: %d\n", error_code);
} else {
printf(" 打开失败，错误代码: %d\n", error_code);
}
}
// 清理测试文件
remove("test1.txt");
remove("test2.txt");
remove("test3.txt");
remove("test4.txt");
}
// 演示资源耗尽的情况
void resource_exhaustion() {
printf("\n=== 资源耗尽情况 ===\n");
// 尝试打开大量文件
printf("尝试打开大量文件...\n");
FILE *files[1000];
int opened_count = 0;
int max_files = 0;
// 获取系统限制
#ifdef _WIN32
// Windows: 使用_getmaxstdio
max_files = _getmaxstdio();
printf("系统最大文件数: %d\n", max_files);
#else
// Unix/Linux: 使用sysconf或getdtablesize
max_files = getdtablesize();
printf("文件描述符限制: %d\n", max_files);
#endif
// 尝试打开文件直到失败
for (int i = 0; i < 1000; i++) {
char filename[50];
snprintf(filename, sizeof(filename), "temp_%04d.txt", i);
files[i] = fopen(filename, "w");
if (files[i] == NULL) {
printf("第 %d 个文件打开失败\n", i + 1);
printf("错误: %s\n", strerror(errno));
break;
}
opened_count++;
// 写入一些内容
fprintf(files[i], "文件 %d\n", i);
}
printf("成功打开 %d 个文件\n", opened_count);
// 关闭所有打开的文件
for (int i = 0; i < opened_count; i++) {
fclose(files[i]);
// 删除临时文件
char filename[50];
snprintf(filename, sizeof(filename), "temp_%04d.txt", i);
remove(filename);
}
printf("已关闭所有文件\n");
}
// 演示fopen在不同情况下的返回值
void fopen_return_scenarios() {
printf("\n=== fopen返回值场景分析 ===\n");
// 场景1: 正常情况
printf("场景1: 正常打开文件\n");
FILE *normal = fopen("normal.txt", "w");
if (normal != NULL) {
printf(" 返回值: 有效的FILE指针 (%p)\n", (void*)normal);
fclose(normal);
}
// 场景2: 文件不存在（读取模式）
printf("\n场景2: 文件不存在（读取模式）\n");
FILE *not_exist = fopen("not_exist.txt", "r");
if (not_exist == NULL) {
printf(" 返回值: NULL\n");
printf(" errno: %d (%s)\n", errno, strerror(errno));
}
// 场景3: 权限不足
printf("\n场景3: 权限不足\n");
// 尝试创建需要特殊权限的文件
FILE *no_permission = fopen("/root/test.txt", "w");
if (no_permission == NULL) {
printf(" 返回值: NULL\n");
printf(" errno: %d (%s)\n", errno, strerror(errno));
}
// 场景4: 无效的文件名
printf("\n场景4: 无效的文件名\n");
FILE *invalid_name = fopen("", "w");
if (invalid_name == NULL) {
printf(" 返回值: NULL\n");
printf(" errno: %d (%s)\n", errno, strerror(errno));
}
// 场景5: 无效的模式字符串
printf("\n场景5: 无效的模式字符串\n");
FILE *invalid_mode = fopen("test.txt", "x"); // 无效模式
if (invalid_mode == NULL) {
printf(" 返回值: NULL\n");
printf(" errno: %d (%s)\n", errno, strerror(errno));
}
// 清理
remove("normal.txt");
}
// 最佳实践示例
void best_practices() {
printf("\n=== fopen最佳实践 ===\n");
// 示例1: 完整的文件打开模式
printf("示例1: 完整的文件打开和错误处理\n");
{
const char *filename = "data.txt";
const char *mode = "r";
FILE *file = fopen(filename, mode);
if (file == NULL) {
// 详细的错误信息
fprintf(stderr, "错误: 无法打开文件 '%s' 以模式 '%s'\n",
filename, mode);
fprintf(stderr, "错误代码: %d\n", errno);
fprintf(stderr, "错误描述: %s\n", strerror(errno));
// 根据错误类型采取不同的措施
if (errno == ENOENT) {
fprintf(stderr, "建议: 文件不存在，请检查文件名\n");
} else if (errno == EACCES) {
fprintf(stderr, "建议: 权限不足，请检查文件权限\n");
}
// 返回错误或退出
return;
}
// 文件操作...
fprintf(file, "测试\n");
// 检查写入是否成功
if (ferror(file)) {
fprintf(stderr, "写入文件时发生错误\n");
clearerr(file); // 清除错误标志
}
fclose(file);
printf(" 文件操作成功完成\n");
}
// 示例2: 使用宏简化错误处理
printf("\n示例2: 使用宏简化错误处理\n");
{
const char *filename = "macro_test.txt";
FILE *file = fopen(filename, "w");
CHECK_NULL(file, "打开文件失败");
// 如果CHECK_NULL返回，说明file不为NULL
fprintf(file, "使用宏进行错误处理\n");
fclose(file);
printf(" 文件操作成功\n");
// 清理
remove(filename);
}
// 示例3: 资源自动管理
printf("\n示例3: 使用goto进行资源清理\n");
{
FILE *file1 = NULL;
FILE *file2 = NULL;
FILE *file3 = NULL;
file1 = fopen("res1.txt", "w");
if (file1 == NULL) {
perror("无法打开res1.txt");
goto cleanup;
}
file2 = fopen("res2.txt", "w");
if (file2 == NULL) {
perror("无法打开res2.txt");
goto cleanup;
}
file3 = fopen("res3.txt", "w");
if (file3 == NULL) {
perror("无法打开res3.txt");
goto cleanup;
}
// 所有文件都成功打开
fprintf(file1, "文件1\n");
fprintf(file2, "文件2\n");
fprintf(file3, "文件3\n");
printf(" 所有文件操作成功\n");
cleanup:
// 统一清理资源
if (file1 != NULL) fclose(file1);
if (file2 != NULL) fclose(file2);
if (file3 != NULL) fclose(file3);
// 清理文件
remove("res1.txt");
remove("res2.txt");
remove("res3.txt");
}
printf("\n最佳实践总结：\n");
printf("1. 总是检查fopen的返回值是否为NULL\n");
printf("2. 提供有意义的错误信息，包括文件名和错误原因\n");
printf("3. 使用errno和strerror获取系统错误信息\n");
printf("4. 根据不同的错误类型采取不同的恢复措施\n");
printf("5. 确保在所有退出路径上关闭文件\n");
printf("6. 考虑使用包装函数或宏简化错误处理\n");
}
int main() {
printf("fopen返回值处理演示\n");
printf("===================\n");
basic_return_check();
error_handling_methods();
resource_exhaustion();
fopen_return_scenarios();
best_practices();
printf("\n程序结束。\n");
return 0;
}3.4 文件的关闭(fclose函数)
(1) fclose函数简介
fclose函数用于关闭一个已打开的文件流。它完成以下任务：
- 刷新缓冲区：将缓冲区中未写入的数据写入文件
- 释放资源：释放与文件流相关的系统资源
- 断开连接：断开程序与文件之间的连接
函数原型：
c
int fclose(FILE *stream);参数说明：
stream：要关闭的文件指针，必须是之前由fopen、freopen或tmpfile成功打开的文件指针
返回值：
- 成功：返回0
- 失败：返回EOF（通常是-1），并设置错误标志
(2) fclose函数注意事项
c
// 示例：fclose函数详解
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
// 演示基本的fclose使用
void basic_fclose_demo() {
printf("=== fclose基本使用 ===\n");
// 1. 正常关闭
printf("1. 正常关闭文件：\n");
FILE *file1 = fopen("test1.txt", "w");
if (file1 != NULL) {
fprintf(file1, "测试内容\n");
int result = fclose(file1);
printf(" fclose返回值: %d (0表示成功)\n", result);
printf(" 文件已关闭\n");
}
// 2. 关闭NULL指针
printf("\n2. 关闭NULL指针：\n");
FILE *null_ptr = NULL;
int result = fclose(null_ptr);
printf(" fclose(NULL)返回值: %d\n", result);
printf(" 注意：关闭NULL指针的行为是未定义的\n");
printf(" 某些实现可能返回EOF，某些可能崩溃\n");
// 3. 重复关闭
printf("\n3. 重复关闭文件：\n");
FILE *file2 = fopen("test2.txt", "w");
if (file2 != NULL) {
fprintf(file2, "测试\n");
// 第一次关闭
result = fclose(file2);
printf(" 第一次fclose返回值: %d\n", result);
// 第二次关闭（危险！）
printf(" 尝试第二次关闭...\n");
result = fclose(file2);
printf(" 第二次fclose返回值: %d\n", result);
printf(" 注意：重复关闭已关闭的文件指针是未定义行为\n");
}
// 4. 检查关闭后的文件指针
printf("\n4. 关闭后的文件指针：\n");
FILE *file3 = fopen("test3.txt", "w");
if (file3 != NULL) {
fprintf(file3, "测试\n");
fclose(file3);
// 检查关闭后的指针
printf(" 文件指针值: %p\n", (void*)file3);
printf(" 注意：关闭后文件指针仍然指向原来的地址\n");
printf(" 但该指针已失效，不应再使用\n");
// 将指针设为NULL是好的做法
file3 = NULL;
printf(" 将指针设为NULL后: %p\n", (void*)file3);
}
// 清理
remove("test1.txt");
remove("test2.txt");
remove("test3.txt");
}
// 演示fclose的错误处理
void fclose_error_handling() {
printf("\n=== fclose错误处理 ===\n");
// 创建一个文件并故意制造错误
printf("1. 正常的fclose：\n");
FILE *file = fopen("error_test.txt", "w");
if (file != NULL) {
fprintf(file, "测试数据\n");
// 正常关闭
int result = fclose(file);
if (result == 0) {
printf(" 文件关闭成功\n");
} else {
printf(" 文件关闭失败，返回值: %d\n", result);
printf(" 错误信息: %s\n", strerror(errno));
}
}
// 测试磁盘空间不足的情况（模拟）
printf("\n2. 模拟fclose失败的情况：\n");
printf(" 注意：实际模拟磁盘空间不足比较困难\n");
printf(" 但在以下情况下fclose可能失败：\n");
printf(" - 磁盘空间不足，无法写入缓冲数据\n");
printf(" - 网络文件系统连接中断\n");
printf(" - 文件系统只读\n");
printf(" - 硬件错误\n");
// 演示如何处理fclose失败
printf("\n3. fclose失败的处理：\n");
file = fopen("close_test.txt", "w");
if (file != NULL) {
// 写入大量数据（可能超过缓冲区）
for (int i = 0; i < 1000; i++) {
fprintf(file, "这是第%d行测试数据，用于填充缓冲区\n", i);
}
// 尝试关闭
int close_result = fclose(file);
if (close_result != 0) {
// fclose失败的处理
printf(" fclose失败！\n");
printf(" 错误代码: %d\n", errno);
printf(" 错误信息: %s\n", strerror(errno));
// 尝试恢复措施
printf(" 可能的恢复措施：\n");
printf(" 1. 检查磁盘空间\n");
printf(" 2. 检查文件权限\n");
printf(" 3. 尝试再次关闭（但可能无效）\n");
printf(" 4. 记录错误并继续执行\n");
// 注意：一旦fclose失败，不应再使用该文件指针
// 但某些实现可能允许再次调用fclose
// 为安全起见，最好将指针设为NULL
file = NULL;
} else {
printf(" 文件关闭成功\n");
}
}
// 清理
remove("error_test.txt");
remove("close_test.txt");
}
// 演示自动资源管理
void automatic_resource_management() {
printf("\n=== 自动资源管理 ===\n");
// 方法1: 使用goto进行清理
printf("方法1: 使用goto进行资源清理\n");
{
FILE *file1 = NULL;
FILE *file2 = NULL;
FILE *file3 = NULL;
file1 = fopen("auto1.txt", "w");
if (file1 == NULL) goto cleanup;
file2 = fopen("auto2.txt", "w");
if (file2 == NULL) goto cleanup;
file3 = fopen("auto3.txt", "w");
if (file3 == NULL) goto cleanup;
// 使用资源
fprintf(file1, "文件1\n");
fprintf(file2, "文件2\n");
fprintf(file3, "文件3\n");
printf(" 所有文件操作成功\n");
cleanup:
// 统一清理，注意顺序（后打开的先关闭）
if (file3 != NULL) {
fclose(file3);
file3 = NULL;
}
if (file2 != NULL) {
fclose(file2);
file2 = NULL;
}
if (file1 != NULL) {
fclose(file1);
file1 = NULL;
}
// 清理文件
remove("auto1.txt");
remove("auto2.txt");
remove("auto3.txt");
}
// 方法2: 使用作用域
printf("\n方法2: 使用作用域限制文件指针生命周期\n");
{
// 内层作用域
{
FILE *file = fopen("scope.txt", "w");
if (file != NULL) {
fprintf(file, "作用域测试\n");
fclose(file);
file = NULL; // 可选，但推荐
}
} // file指针在此处离开作用域
// 此处不能访问file指针
printf(" 文件指针已离开作用域\n");
// 清理文件
remove("scope.txt");
}
// 方法3: 使用包装函数
printf("\n方法3: 使用包装函数自动管理资源\n");
// 定义一个文件处理函数
void process_file(const char *filename) {
FILE *file = fopen(filename, "w");
if (file == NULL) {
perror("无法打开文件");
return;
}
// 使用文件
fprintf(file, "包装函数测试\n");
// 自动关闭
fclose(file);
printf(" 文件已处理并自动关闭\n");
}
process_file("wrapper.txt");
remove("wrapper.txt");
}
// 演示缓冲区和fclose的关系
void buffer_and_fclose() {
printf("\n=== 缓冲区与fclose的关系 ===\n");
// 1. 缓冲区未刷新的情况
printf("1. 缓冲区未刷新的危险：\n");
{
FILE *file = fopen("buffer_test.txt", "w");
if (file != NULL) {
fprintf(file, "这行数据在缓冲区中");
// 不调用fclose或fflush
// 程序直接退出
printf(" 数据已写入缓冲区，但未刷新到磁盘\n");
printf(" 如果没有fclose，数据可能丢失！\n");
// 正确做法：总是关闭文件
fclose(file);
}
}
// 2. 设置缓冲区大小
printf("\n2. 设置缓冲区大小：\n");
{
FILE *file = fopen("buffer_size.txt", "w");
if (file != NULL) {
// 设置缓冲区
char buffer[1024];
setvbuf(file, buffer, _IOFBF, sizeof(buffer));
fprintf(file, "测试缓冲区设置\n");
// 手动刷新缓冲区
fflush(file);
printf(" 缓冲区已手动刷新\n");
fclose(file);
}
remove("buffer_size.txt");
}
// 3. 无缓冲模式
printf("\n3. 无缓冲模式：\n");
{
FILE *file = fopen("unbuffered.txt", "w");
if (file != NULL) {
// 设置为无缓冲
setbuf(file, NULL);
fprintf(file, "无缓冲写入\n");
printf(" 数据立即写入磁盘（无缓冲）\n");
fclose(file);
}
remove("unbuffered.txt");
}
// 4. fclose自动刷新缓冲区
printf("\n4. fclose自动刷新缓冲区：\n");
{
FILE *file = fopen("autoflush.txt", "w");
if (file != NULL) {
// 写入大量数据，填充缓冲区
for (int i = 0; i < 100; i++) {
fprintf(file, "行 %03d: 测试数据测试数据测试数据\n", i);
}
printf(" 已写入100行数据到缓冲区\n");
printf(" 调用fclose将自动刷新缓冲区\n");
int result = fclose(file);
if (result == 0) {
printf(" fclose成功，缓冲区已刷新\n");
} else {
printf(" fclose失败，数据可能丢失！\n");
}
}
// 验证文件内容
file = fopen("autoflush.txt", "r");
if (file != NULL) {
int line_count = 0;
char buffer[256];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
line_count++;
}
fclose(file);
printf(" 文件实际包含 %d 行数据\n", line_count);
}
remove("autoflush.txt");
}
}
// 演示多线程环境下的fclose
void multithread_fclose() {
printf("\n=== 多线程与fclose ===\n");
printf("警告：多线程环境下操作同一文件需要同步！\n");
printf("\n常见问题：\n");
printf("1. 线程A正在读取文件，线程B关闭了文件\n");
printf("2. 线程A和线程B同时调用fclose\n");
printf("3. 一个线程关闭文件后，另一个线程继续使用文件指针\n");
printf("\n安全建议：\n");
printf("1. 每个线程使用自己的文件指针\n");
printf("2. 使用互斥锁保护文件操作\n");
printf("3. 避免在多线程间共享文件指针\n");
printf("4. 如果必须共享，确保正确的同步\n");
printf("\n示例：线程安全的文件操作结构\n");
// 线程安全的文件包装器结构
typedef struct {
FILE *file;
#ifdef _WIN32
HANDLE mutex;
#else
pthread_mutex_t mutex;
#endif
const char *filename;
} ThreadSafeFile;
printf(" 使用互斥锁保护文件操作\n");
printf(" 确保打开、读写、关闭操作都是原子的\n");
}
// 最佳实践总结
void fclose_best_practices() {
printf("\n=== fclose最佳实践 ===\n");
printf("1. 总是检查fopen的返回值\n");
{
FILE *file = fopen("test.txt", "r");
if (file == NULL) {
// 处理错误
printf(" 示例：检查fopen返回值 ✓\n");
} else {
fclose(file);
}
}
printf("\n2. 每个fopen对应一个fclose\n");
{
FILE *file1 = fopen("test1.txt", "w");
FILE *file2 = fopen("test2.txt", "w");
if (file1 != NULL) fclose(file1);
if (file2 != NULL) fclose(file2);
printf(" 示例：对称的资源管理 ✓\n");
remove("test1.txt");
remove("test2.txt");
}
printf("\n3. 在错误路径上也关闭文件\n");
{
FILE *file = fopen("test.txt", "w");
if (file != NULL) {
if (/* 某些条件 */ 1) {
// 正常路径
fprintf(file, "数据\n");
fclose(file);
} else {
// 错误路径
fclose(file); // 也要关闭！
}
printf(" 示例：所有路径都关闭文件 ✓\n");
}
}
printf("\n4. 关闭后将指针设为NULL\n");
{
FILE *file = fopen("test.txt", "w");
if (file != NULL) {
fprintf(file, "测试\n");
fclose(file);
file = NULL; // 防止误用
printf(" 示例：关闭后设为NULL ✓\n");
}
remove("test.txt");
}
printf("\n5. 注意关闭顺序\n");
{
// 如果有多个相关文件，考虑关闭顺序
FILE *source = fopen("src.txt", "r");
FILE *dest = fopen("dest.txt", "w");
if (source != NULL && dest != NULL) {
// 处理文件...
// 先关闭目标文件（可能包含重要数据）
fclose(dest);
dest = NULL;
// 然后关闭源文件
fclose(source);
source = NULL;
printf(" 示例：合理的关闭顺序 ✓\n");
}
// 清理
if (dest != NULL) fclose(dest);
if (source != NULL) fclose(source);
remove("src.txt");
remove("dest.txt");
}
printf("\n6. 处理fclose的返回值\n");
{
FILE *file = fopen("test.txt", "w");
if (file != NULL) {
fprintf(file, "重要数据\n");
int result = fclose(file);
if (result != 0) {
printf(" 警告：fclose失败，数据可能未保存！\n");
printf(" 错误：%s\n", strerror(errno));
} else {
printf(" 示例：检查fclose返回值 ✓\n");
}
}
remove("test.txt");
}
printf("\n7. 使用RAII模式（C++）或类似模式\n");
printf(" 在C语言中，可以使用以下模式模拟RAII：\n");
printf(" - 使用goto统一清理\n");
printf(" - 使用作用域限制生命周期\n");
printf(" - 使用包装函数\n");
printf(" - 使用清理函数注册\n");
printf("\n总结：\n");
printf("fclose不仅是释放资源，还确保数据完整性\n");
printf("正确的文件关闭是健壮程序的基础\n");
}
int main() {
printf("fclose函数详解演示\n");
printf("==================\n");
basic_fclose_demo();
fclose_error_handling();
automatic_resource_management();
buffer_and_fclose();
multithread_fclose();
fclose_best_practices();
printf("\n程序结束。\n");
return 0;
}fclose的深入理解
-
缓冲区刷新机制 ：
fclose会自动刷新文件的输出缓冲区，确保所有缓冲的数据都写入磁盘。如果程序异常终止而没有调用fclose，缓冲区的数据可能会丢失。 -
资源泄漏 ：不调用
fclose会导致文件描述符泄漏。在长时间运行的程序中，过多的文件描述符泄漏可能导致程序无法打开新文件。 -
文件锁释放 ：在某些操作系统中，打开文件可能会创建文件锁。
fclose会释放这些锁，允许其他进程访问文件。 -
错误处理 ：虽然
fclose通常很少失败，但在某些情况下（如磁盘空间不足、硬件故障）可能会失败。健壮的程序应该检查fclose的返回值。 -
顺序问题：当多个文件相互关联时（如一个文件的处理依赖于另一个文件），关闭文件的顺序可能很重要。通常，应该先关闭依赖其他文件的文件。
总结
本文详细介绍了C语言中文件操作的基础------文件的打开与关闭。通过深入探讨fopen和fclose函数，我们了解了：
-
文件的基本概念：文件是数据持久化存储的基础，在程序中扮演着重要角色。
-
数据文件的分类：文本文件和二进制文件各有特点，适用于不同的场景。
-
流和标准流：C语言通过流的概念抽象了文件操作，标准流（stdin、stdout、stderr）提供了基本的输入输出功能。
-
文件指针 ：
FILE指针是文件操作的核心，它封装了文件的所有状态信息。 -
fopen函数：
- 用于打开文件，建立程序与文件的连接
- 需要指定文件名和打开模式
- 返回值必须检查，NULL表示打开失败
- 支持多种打开模式，满足不同的需求
-
fclose函数：
- 用于关闭文件，释放资源
- 会自动刷新缓冲区，确保数据完整性
- 应该与
fopen配对使用 - 返回值应该检查，以处理可能的错误
正确使用fopen和fclose是文件操作的基础，也是编写健壮、可靠程序的关键。在实际编程中，应该始终遵循以下原则：
- 总是检查
fopen的返回值 - 每个
fopen都应该对应一个fclose - 在错误处理路径上也不要忘记关闭文件
- 考虑使用包装函数或宏来简化错误处理
- 在多线程环境中特别注意文件指针的同步
掌握了文件的打开与关闭后，我们已经为学习更高级的文件操作（如读写、定位、错误处理等）打下了坚实的基础。在后续的文章中，我们将继续探讨这些主题，帮助读者全面掌握C语言文件操作的各个方面。
参考文献
-
Kernighan, B. W., & Ritchie, D. M. (1988). The C Programming Language (2nd ed.). Prentice Hall.
-
ISO/IEC 9899:2018. Programming languages --- C. International Organization for Standardization.
-
Plauger, P. J. (1992). The Standard C Library. Prentice Hall.
-
Stevens, W. R., & Rago, S. A. (2013). Advanced Programming in the UNIX Environment (3rd ed.). Addison-Wesley.
-
Linux Programmer's Manual. fopen(3), fclose(3).
-
Microsoft Docs. fopen, _wfopen. https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fopen-wfopen
-
GNU C Library Manual. Opening and Closing Files. https://www.gnu.org/software/libc/manual/html_node/Opening-and-Closing-Files.html
注意：本文中的代码示例主要用于教学目的，在实际项目中使用时需要考虑更多的错误处理、资源管理和安全性问题。