C语言进阶6:文件操作

于 2024-11-24 01:22:41 发布
阅读量254 收藏 3
点赞数 4
分类专栏： # C语言笔记 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ydm_ymz/article/details/144001845
版权

本章重点

  1. 为什么使用文件
  2. 什么是文件
  3. 文件的打开和关闭
  4. 文件的顺序读写
  5. 文件的随机读写
  6. 文本文件和二进制文件
  7. 文件读取结束的判定
  8. 文件缓冲区

文章目录

1.为什么使用文件

我们在使用通讯录时需要把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。

使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

2.什么是文件

磁盘上的文件是文件。

但是在程序设计中，我们一般谈的文件有两种：
从文件功能的角度来分：程序文件、数据文件

2.1 程序文件

包括：

源程序文件（后缀为.c）
目标文件（windows环境后缀为.obj）
可执行程序（windows环境 后缀为.exe）

2.2 数据文件

文件的内容不一定是程序，而是程序运行时读写的数据，
比如程序运行需要从中读取数据的文件， 或者输出内容的文件

本关讨论的是数据文件。

在以前各关所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上

其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上的文件。

2.3 文件名

一个文件要有一个唯一的文件标识。

文件名包含3部分：文件路径+文件名主干+文件后缀

例如： 'c: \ code \ test.txt ’ 为了方便起见，文件标识常被称为文件名。

3.文件的打开和关闭

3.1 文件指针

缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息
（如文件的名字，文件状态及文件当前的位置等）
这些信息是保存在一个结构体变量中的。

该结构体类型是有系统声明的，取名FILE.

例如，VS2013编译环境提供的 stdio.h 头文件中有以下的文件类型申明：

struct _iobuf 
{
   char* _ptr;
   int   _cnt;
   char* _base;
   int   _flag;
   int   _file;
   int   _charbuf;
   int   _bufsiz;
   char* _tmpfname;
};
typedef struct _iobuf FILE;

不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。

每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息， 使用者不必关心细节
一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。

我们可以创建一个FILE * 的指针变量：

FILE* pf;//文件指针变量

定义pf是一个指向FILE类型数据的指针变量。

可以使pf指向某个文件的文件信息区（是一个结构体变量。

通过该文件信息区中的信息就能够访问该文件。

也就是说，通过文件指针变量能够找到与它关联的文件。
请添加图片描述

3.2 文件的打开和关闭

文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。

在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，也相当于建立了指针和文件的关系

ANSIC 规定使用fopen函数来打开文件 ; fclose来关闭文件

打开文件
FILE* fopen(const char* filename, const char* mode);
                        文件名             文件的打开方式
关闭文件
int fclose(FILE* stream);

打开方式如下：

请添加图片描述

文件操作全过程代码如下：

int main()
{
	//打开文件
	FILE*pf = fopen("test.txt", "w");
    //这里只写文件名的话就会在工程目录里面创建该文件 
  	//或  .\test.txt    ;    ..\test.txt是上一级目录
    FILE*pf1 = fopen("c:\\code\\test1.txt", "w");
    //这里加上路径就会在指定路径里面建立该文件    
 
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
 
	//写文件
 
 
	//关闭文件
	fclose(pf);
	pf = NULL;
 
	return 0;
}

4.文件的顺序读写

功能函数名适用于
字符输入函数fgetc所有输入流
字符输出函数fputc所有输出流
文本行输入函数fgets所有输入流
文本行输出函数fputs所有输出流
格式化输入函数fscanf所有输入流
格式化输出函数fprintf所有输出流
二进制输入fread文件
二进制输出fwrite文件

请添加图片描述

4.1 字符 输入 输出 函数

文件的写入（字符类型）：

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
    //注意！！！
    //这用的是 "w":只写，所以我们在再次写入数据的时候，之前的数据会被清空，
    //如果不想让之前的数据被清空，我们可以用 "a"：追加，在文件尾部添加数据
 
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
 
	//写文件
	int i = 0;
	for (i = 0; i < 26; i++)
	{
		fputc('a'+i, pf);//一个字符一个字符的写
	}
 
    //关闭文件
	fclose(pf);
	pf = NULL;
 
	return 0;
}

文件的读取（字符类型）：

int main()
{
    //打开文件
	FILE* pf = fopen("test.txt", "w");
 
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
 
	//读文件
	int ch = 0;
	while ((ch = fgetc(pf)) != EOF)//fgetc读取失败后会返回EOF
	{
		printf("%c ", ch);
	}
 
	//关闭文件
	fclose(pf);
	pf = NULL;
 
	return 0;
}

4.2 文本行的 输入 输出 函数

文件的写入（文本行）：

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "w");
 
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
 
	//写文件-一行一行写
	fputs("hello\n", pf);//这里需要手动加\n才会在文件里面换行
	fputs("world\n", pf);
 
	//关闭文件
	fclose(pf);
	pf = NULL;
 
	return 0;
}

文件的读取（文本行）：

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
 
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
 
	//读文件-一行一行读
	char arr[20] = "#########";
 
	fgets(arr, 20, pf);//这里虽然写的是20，但只会读前19个，第20个元素里面会放入'\0'
	printf("%s", arr);
	
	fgets(arr, 20, pf);
	printf("%s", arr);
 
 
	//关闭文件
	fclose(pf);
	pf = NULL;
 
	return 0;
}

4.3 格式化的 输入 输出 函数

适用于结构体类型的输入输出

文件的写入（格式化）：

struct S
{
	char name[20];
	int age;
	float score;
};
 
int main()
{
	struct S s = { "zhangsan", 20, 95.5f };
 
	//把s中的数据写到文件中
	FILE*pf = fopen("test.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
 
	//写文件
	fprintf(pf, "%s %d %.1f", s.name, s.age, s.score);
    //和printf用法类似
 
	fclose(pf);
	pf = NULL;
	return 0;
}

文件的读取（格式化）：

struct S
{
	char name[20];
	int age;
	float score;
};
 
int main()
{
	struct S s = {0};
	//把s中的数据写到文件中
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
 
	//读文件
	fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));
 
	printf("%s %d %f\n", s.name, s.age, s.score);
 
	fclose(pf);
	pf = NULL;
	return 0;
}

4.4 二进制的 输入 输出 函数

文件的写入（二进制）：

struct S
{
	char name[20];
	int age;
	float score;
};
 
int main()
{
	struct S s = { "zhangsan", 20, 95.5f };
	//把s中的数据写到文件中
	FILE*pf = fopen("test.txt", "wb");//注意这里是wb，写二进制文件
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
 
	//二进制的写文件，用fwrite
	fwrite(&s, sizeof(s), 1, pf);
 
	fclose(pf);
	pf = NULL;
	return 0;
}

二进制写入的文件一般会在文件里面显示一些乱码，但计算机用二进制可以读取出来

文件的读取（二进制）：

struct S
{
	char name[20];
	int age;
	float score;
};
 
int main()
{
	struct S s = {0};
	//把s中的数据写到文件中
	FILE* pf = fopen("test.txt", "rb");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//二进制的读文件
	fread(&s, sizeof(s), 1, pf);
 
	printf("%s %d %f\n", s.name, s.age, s.score);
 
	fclose(pf);
	pf = NULL;
	return 0;
}

4.5 C语言默认数据流

函数名适用于
fscanf所有输入流
fprintf所有输出流

可以看到这两个函数是所有输入或输出流，所以他们也可以从键盘上读取，也可以显示到屏幕
用法就和scanf与printf一样

但大家有没有发现，为什么在我们操作文件时，有打开文件和关闭文件的操作？而在读取键盘上的东西，和，打印到屏幕上的东西却没有打开键盘之类的操作？

这是因为对任意一个C程序，只要运行起来，就默认打开3个流：
stdin——标准输入流——键盘
stdout——标准输出流——屏幕
stderr——标准输出流——屏幕

如果我们想用fscanf读取键盘上的数，用fprintf打印到屏幕上时，可以这样写：

int main()
{
    int ch=fgets(stdin);
    fputs(ch,stdout);
 
    return 0;
}

这样就能读取键盘的数，并打印到屏幕上

4.6 对比一组函数：

scanf / fscanf / sscanf
printf / fprintf / sprintf

scanf：按照一定的格式从键盘输入数据
printf：按照一定的格式把数据打印（输出）到屏幕上
//适用于标准输入 / 输出流的格式化的输入，输出语句

fscanf：按照一定的格式从输入流（文件/stdin）输入数据
fprintf：按照一定的格式向输出流（文件/stdout）输出数据
//适用于所有的 输入 / 输出流 的格式化 输入 / 输出语句

sscanf： 从字符串中按照一定的格式读取出格式化的数据
sprintf： 把格式话的数据按照一定格式转换成字符串

可以参照如下代码：

struct s
{
	char name[10];
	int age;
	float score;
};
 
int main()
{
	char buf[100] = {0};
 
	struct s s = { "zhangsan", 20, 95.5f };
	
	sprintf(buf, "%s %d %f", s.name, s.age, s.score);
	//能够把这个结构体的数据，转换成字符串："zhangsan 20 95.5"  也成为序列化
	printf("%s\n", buf);
	//以字符串形式打印
 
	struct s tmp = { 0 };
	//能否将buf中的字符串，还原成一个结构体数据呢？
	sscanf(buf, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
	//还原成为结构体   也成为反序列化
	printf("%s %d %f\n", tmp.name, tmp.age, tmp.score);
	//以结构的形式打印
 
	return 0;
}

5.通讯录(文件储存,管理)

test.c - 测试通讯录
contact.c - 通讯录实现
contact.h - 函数声明

contact.h - 函数声明

#pragma once
#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<stdlib.h>
#define MAX 100
#define NAME_MAX 20
#define SEX_MAX 5
#define ADDR_MAX 30
#define TELE_MAX 30

#define DEFAULT_SZ 3
#define INC_SZ 2
typedef struct PeoInfo
{
	char name[NAME_MAX];
	int age;
	char sex[SEX_MAX];
	char addr[ADDR_MAX];
	char tele[TELE_MAX];
}PeoInfo;

typedef struct Contact
{
	PeoInfo* data;//指向存放人的信息的空间
	int sz;//当前已经存放信息个数
	int capacity;//当前通讯录的最大容量
}Contact;


//初始化通讯录
void InitContact(Contact* pc);
//销毁通讯录
void DestroyContact(Contact* pc);
//增加联系人
void ADDContact(Contact* pc);

//删除指定联系人
void DelContact(Contact* pc);

//显示通讯录中的信息
void ShowContact(const Contact* pc);

//查找指定联系人
void SearchContact(const Contact* pc);

//修改指定联系人
void ModifyContact(Contact* pc);

// 保存通讯录信息到文件中
void SaveContact(Contact* pc);

//加载文件信息到通讯录
void LoadContact(Contact* pc);

contact.c - 通讯录实现

#define _CRT_SECURE_NO_WARNINGS 1
#include"contact.h"

void InitContact(Contact* pc)
{
	assert(pc);
	pc->sz = 0;
	PeoInfo* ptr = (PeoInfo*)calloc(DEFAULT_SZ,sizeof(PeoInfo));
	if (ptr == NULL)
	{
		perror("InitContact::calloc");
		return;
	}
	pc->data =ptr ;
	pc->capacity = DEFAULT_SZ;

	//加载文件信息到通讯录
	LoadContact(pc);

}
void DestroyContact(Contact* pc)
{
	assert(pc);
	free(pc->data);
	pc ->data=NULL;
	pc->capacity = 0;
	pc->sz = 0;
	pc = NULL;
}

int FindByName(const Contact* pc, char name[])
{
	assert(pc);
	int i = 0;
	for (i = 0; i < pc->sz; i++)
	{
		if (strcmp(pc->data[i].name, name) == 0)
		{
			return i;
		}
	}
	return -1;
}

void check_capacity(Contact* pc)
{
	if (pc->sz == pc->capacity)
	{
		//增加容量
		PeoInfo* ptr= (PeoInfo*)realloc(pc->data, (pc->capacity+ INC_SZ)*sizeof(PeoInfo));
		if (ptr == NULL)
		{
			perror("check_capacity::reallo");
			return;
		}
		pc->data = ptr;
		pc->capacity += INC_SZ;
		printf("增容成功!\n");

	}
}
void ADDContact(Contact* pc)
{
	assert(pc);
	check_capacity(pc);

	
	//增加一个人信息
	printf("请输入名字:>");
	scanf("%s", pc->data[pc->sz].name);
	printf("请输入年龄:>");
	scanf("%d", &(pc->data[pc->sz].age));
	printf("请输入性别:>");
	scanf("%s", pc->data[pc->sz].sex);
	printf("请输入地址:>");
	scanf("%s", pc->data[pc->sz].addr);
	printf("请输入电话:>");
	scanf("%s", pc->data[pc->sz].tele);
	pc->sz++;
	printf("添加成功!\n");
}
void ShowContact(const Contact* pc)
{
	assert(pc);
	int i = 0;
	printf("|%-20s|%-4s\t|%-5s\t|%-20s\t|%-12s|\n","名字","年龄","性别","地址","电话");
	printf("|--------------------|----------|-------|-----------------------|------------|\n");
	for (i = 0; i < pc->sz; i++)
	{
		printf("|%-20s|%-4d\t|%-5s\t|%-20s\t|%-12s|\n", pc->data[i].name, pc->data[i].age, pc->data[i].sex, pc->data[i].addr, pc->data[i].tele);
	}
}

void DelContact(Contact* pc)
{
	assert(pc);
	char name[NAME_MAX] = { 0 };
	if (pc->sz == 0)
	{
		printf("通讯录为空,无法删除\n");
		return;
	}
	//删除
	//找到要删除的人
	printf("请输入要删除的人:>");
	scanf("%s",name);
	int ret=FindByName(pc, name);
	if (-1 == ret)
	{
		printf("删除信息不存在\n");
		return;
	}
	int i = 0;
	//删除
	for (i = ret; i < pc->sz - 1; i++)
	{
		pc->data[i] = pc->data[i + i];
	}
	printf("删除成功!\n");
}

void SearchContact(const Contact* pc)
{
	assert(pc);
	char name[NAME_MAX] = { 0 };
	printf("请输入查找人姓名:>");
	scanf("%s", name);
	int pos = FindByName(pc, name);
	if (-1 == pos)
	{
		printf("查找信息不存在\n");
		return;
	}
	printf("|%-20s|%-4s\t|%-5s\t|%-20s\t|%-12s|\n", "名字", "年龄", "性别", "地址", "电话");
	printf("|--------------------|----------|-------|-----------------------|------------|\n");
	printf("|%-20s|%-4d\t|%-5s\t|%-20s\t|%-12s|\n", pc->data[pos].name, pc->data[pos].age, pc->data[pos].sex, pc->data[pos].addr, pc->data[pos].tele);
}

void ModifyContact(Contact* pc)
{
	assert(pc);
	char name[NAME_MAX] = { 0 };
	printf("请输入修改人姓名:>");
	scanf("%s", name);
	int pos = FindByName(pc, name);
	if (-1 == pos)
	{
		printf("查找信息不存在\n");
		return;
	}
	printf("请输入名字:>");
	scanf("%s", pc->data[pos].name);
	printf("请输入年龄:>");
	scanf("%d", &(pc->data[pos].age));
	printf("请输入性别:>");
	scanf("%s", pc->data[pos].sex);
	printf("请输入地址:>");
	scanf("%s", pc->data[pos].addr);
	printf("请输入电话:>");
	scanf("%s", pc->data[pos].tele);
	printf("修改成功!\n");
}

void SaveContact(Contact* pc)
{
	//写数据
	//1.打开数据
	FILE* pf = fopen("contact.txt", "wb");
	if (NULL == pf)
	{
		perror("SaveContact");
	}
	else
	{
		//写数据
		int i = 0;
		for (i = 0; i < pc->sz; i++)
		{
			fwrite(pc->data+i,sizeof(PeoInfo),1,pf);
		}
		fclose(pf);
		pf = NULL;
		printf("保存成功\n");
	}
}

void LoadContact(Contact* pc)
{
	//读数据
	//1.打开文件
	FILE* pf = fopen("contact.txt", "wb");
	if (NULL == pf)
	{
		perror("LoadContact");
	}
	else 
	{
		//2.打开文件
		PeoInfo tmp = { 0 };
		int i = 0;
		while (fread(&tmp, sizeof(PeoInfo), 1, pf))
		{
			//增容

			check_capacity(pc);
			pc->data[i] = tmp;
			pc->sz++;
			i++;
		}
		fclose(pf);
		pf = NULL;
	}

}

test.c - 测试通讯录

#define _CRT_SECURE_NO_WARNINGS 1
#include"contact.h"

void menu()
{
	printf("***********************************\n");
	printf("*****   1. add      2. del    *****\n");
	printf("*****   3. search   4. modify *****\n");
	printf("*****   5. show     6. sort   *****\n");
	printf("*****   0. exit               *****\n");
	printf("***********************************\n");
}
int main()
{
	int input;
	//创建通讯录
	Contact con;
	//初始化通讯录
	InitContact(&con);
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			ADDContact(&con);
			break;
		case 2:
			DelContact(&con);
			break;
		case 3:
			SearchContact(&con);
			break;
		case 4:
			ModifyContact(&con);
			break;
		case 5:
			ShowContact(&con);
			break;
		case 6:
			break;
		case 0:
			// 保存通讯录信息到文件中
			SaveContact(&con);
			DestroyContact(&con);
			printf("退出通讯录\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

6.文件的随机读写

6.1 fseek

根据文件指针的位置和偏移量来定位文件指针。

int fseek ( FILE * stream, long int offset, int origin );
offest：偏移量， origin：起始位置
在stream文件流中从哪开始偏移多少。

origin起始位置：用下面三个表示

constantreference position
SEEK_SET从起始元素位置开始读
SEEK_CUR从文件当前位置开始读
SEEK_END从文件最后一个元首位置开始读
int main()
{
	FILE*pf = fopen("test.txt", "r");
	//r：只读，需要提前创建好一个文件，
	//我们在文件里面写入：abcdef
	if (pf == NULL)
	{
		perror("fopen()");
		return 1;
	}
	//读文件
	//按照顺序读
	int ch = fgetc(pf);
	printf("%c\n", ch);//找到a并读取
	//继续调用
	ch = fgetc(pf);
	printf("%c\n", ch);//找到d并读取
	//读完后指针向后移动一位
 
	fseek(pf, 1, SEEK_CUR);//从文件当前指针开始偏移1个位置（负数往前偏移，整数往后偏移）
	int pos1 = fgetc(pf);
	printf("%c\n", pos1);//打印d
 
	fseek(pf, 3, SEEK_SET);//从文件第一个元素开始向后偏移3个位置
	int pos2 = fgetc(pf);
	printf("%c\n", pos2);//打印d
 
	fseek(pf, -3, SEEK_END);//从文件最后一个元素开始往前（注意偏移量是负数）偏移3个位置
	int pos3 = fgetc(pf);
	printf("%c\n", pos3);//打印d
 
	fclose(pf);
	pf = NULL;
	return 0;
}

6.2 ftell

返回文件指针相对于起始位置的偏移量

long int ftell ( FILE * stream );

int main()
{
	FILE* pf = fopen("test.txt", "r");
	//我们在文件里面写入：abcdef
	if (pf == NULL)
	{
		perror("fopen()");
		return 1;
	}
 
	fseek(pf, 3, SEEK_SET);//向后偏移了三个元素
	int ch = fgetc(pf);
	printf("%c\n", ch);
    
	int pds = ftell(pf);//这是应该指向第4个元素
	printf("%d\n", pds);//4
 
	fclose(pf);
	pf = NULL;
	return 0;
}

6.3 rewind

让文件指针的位置回到文件的起始位置

void rewind ( FILE * stream );

int main()
{
	FILE* pf = fopen("test.txt", "r");
	//我们在文件里面写入：abcdef
	if (pf == NULL)
	{
		perror("fopen()");
		return 1;
	}
 
	fseek(pf, 3, SEEK_SET);//向后偏移了三个元素
	int ch = fgetc(pf);
	printf("%c\n", ch);
    
    rewind(pf);//将指针指向第一个元素
    
	int pds = ftell(pf);//这是应该指向第1个元素
	printf("%d\n", pds);//1
 
	fclose(pf);
	pf = NULL;
	return 0;
}

7.文本文件和二进制文件

根据数据的组织形式，数据文件被称为文本文件或者二进制文件。

数据在内存中以二进制的形式二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。
如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

一个数据在内存中是怎么存储的呢？
字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节

8.文件读取结束的判定

8.1 被错误使用的feof

牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。

而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

  1. 文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
    例如：

fgetc 判断是否为 EOF .
- getc

  • 如果读取正常，会返回读取到的字符的ASCII值
  • 如果读取失败，EOF

fgets 判断返回值是否为 NULL .

  • fgets
  • 如果读取正常，返回的是存放读取到的数据的地址
  • 如果读取失败，返回的是NULL
  1. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
    例如：

fread 判断返回值是否小于实际要读的个数

其他函数：
fscanf

  • 如果读取正常，返回的是格式串中指定的数据个数
  • 如果读取失败，返回的是小于格式串中指定的数据的个数

8.2 正确使用文件的例子

正确的使用文本文件的例子：

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    int c; // 注意：int，非char，要求处理EOF
    FILE* fp = fopen("test.txt", "r");
    if (!fp) 
    {
        perror("File opening failed");
        return EXIT_FAILURE;
    }
    //fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
    while ((c = fgetc(fp)) != EOF) // 标准C I/O读取文件循环
    {
        putchar(c);
    }
    //判断是什么原因结束的
    if (ferror(fp))
        puts("I/O error when reading");
    else if (feof(fp))
        puts("End of file reached successfully");
    fclose(fp);![请添加图片描述](https://i-blog.csdnimg.cn/direct/0a7558e963454ed79655524615fd3428.png)

}

正确使用二进制文件的例子：

#include <stdio.h>
enum { SIZE = 5 };
int main(void)
{
    double a[SIZE] = {1.,2.,3.,4.,5.};
    FILE *fp = fopen("test.bin", "wb"); // 必须用二进制模式
 
    fwrite(a, sizeof *a, SIZE, fp); // 写 double 的数组
    fclose(fp);
 
    double b[SIZE];
    fp = fopen("test.bin","rb");
    size_t ret_code = fread(b, sizeof *b, SIZE, fp); // 读 double 的数组
 
    if(ret_code == SIZE)
    {
        puts("Array read successfully, contents: ");
        for(int n = 0; n < SIZE; ++n) printf("%f ", b[n]);
        putchar('\n');
 
    }
    else// error handling 
    { 
        if (feof(fp))
           printf("Error reading test.bin: unexpected end of file\n");
        else if (ferror(fp))
           perror("Error reading test.bin");
    }
    fclose(fp);
}

9.文件缓冲区

ANSIC 标准采用“缓冲文件系统”处理的数据文件的，所谓缓冲文件系统是指系统自动地在内存中为程序 中每一个正在使用的文件开辟一块“文件缓冲区”。从内存向磁盘输出数据会先送到内存中的缓冲区，装 满缓冲区后才一起送到磁盘上。如果从磁盘向计算机读入数据，则从磁盘文件中读取数据输入到内存缓 冲区（充满缓冲区），然后再从缓冲区逐个地将数据送到程序数据区（程序变量等）。缓冲区的大小根 据C编译系统决定的。
请添加图片描述

通俗来讲（举个例子）：
就像是在你写word文件的时候，没写一段时间，会进行一次保存，而没保存之前，文件就放在文件缓冲区中，当你点击保存后，才会放到磁盘中

这样做的原因是为了提高效率。

可以通过下面代码来测试缓冲区的存在

#include <stdio.h>
#include <windows.h>
//VS2019 WIN11环境测试
int main()
{
 FILE*pf = fopen("test.txt", "w");
 fputs("abcdef", pf);//先将代码放在输出缓冲区
 printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
 
 Sleep(10000);//单位是毫秒，想当于10s
 
 printf("刷新缓冲区\n");
 fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
 //注：fflush 在高版本的VS上不能使用了
 printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
 
 Sleep(10000);
 
 fclose(pf);
 //注：fclose在关闭文件的时候，也会刷新缓冲区
 pf = NULL;
 return 0;
}

这里可以得出一个结论：
因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件。
如果不做，可能导致读写文件的问题。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值