• 文件操作上（C语言)

    作者：旧梦拾遗186

    专栏：C语言编程----小比特成长日记

     

    每日励志：

    改变，永远不嫌晚。无论你是几岁，也无论你目前所处的境况有多糟，只要立定目标、一步一步往前走，人生随时都有翻盘的可能性。

    前言：

    今天小编带大家来认识下文件的操作，包括顺序读写。

    目录

    一.为什么使用文件

    二.什么是文件

    2.1程序文件 

    2.2数据文件 

    2.3 文件名

    三. 文件的打开和关闭  

     3.2 文件的打开和关闭

    四. 文件的顺序读写 

    fputs

    fgetc

    fgets

    fprintf

    fscanf 

    fwrite

    read

    sprintf:

    sscanf

    一.为什么使用文件

    我们前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数 据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯 录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。
    我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
    这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据 库等方式。
    使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。

    二.什么是文件

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

    2.1程序文件 

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

    2.2数据文件 

    文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，
    或者输出内容的文件。
    本章讨论的是数据文件。
    在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行果显示到显 示器上。
    其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理 的就是磁盘上文件。

     

     2.3 文件名

    一个文件要有一个唯一的文件标识，以便用户识别和引用。
    文件名包含 3 部分： 文件路径+文件名主干+文件后缀
    例如： c:\code\test.txt
    为了方便起见，文件标识常被称为 文件名 。

    三. 文件的打开和关闭  

    缓冲文件系统中，关键的概念是 “ 文件类型指针 ” ，简称 “ 文件指针 ” 。
    每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名 字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统 声明的，取名FILE.
    例如， VS2013 编译环境提供的 stdio.h 头文件中有以下的文件类型申明： 
    1. struct _iobuf {
    2.         char *_ptr;
    3.         int   _cnt;
    4.         char *_base;
    5.         int   _flag;
    6.         int   _file;
    7.         int   _charbuf;
    8.         int   _bufsiz;
    9.         char *_tmpfname;
    10.        };
    11. typedef struct _iobuf FILE;
    12. FILE* pf;//文件指针变量
    不同的 C 编译器的 FILE 类型包含的内容不完全相同，但是大同小异。
    每当打开一个文件的时候，系统会根据文件的情况自动创建一个 FILE 结构的变量，并填充其中的信息，
    使用者不必关心细节。
    一般都是通过一个 FILE 的指针来维护这个 FILE 结构的变量，这样使用起来更加方便。

    下面我们可以创建一个FILE*的指针变量: 

    FILE* pf;//文件指针变量
    定义 pf 是一个指向 FILE 类型数据的指针变量。 可以使pf指向某个文件的文件信息区（是一个结构体变 量） 。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联 的文件 。

     

     3.2 文件的打开和关闭

    文件在读写之前应该先 打开文件 ，在使用结束之后应该 关闭文件 。
    在编写程序的时候，在打开文件的同时，都会返回一个 FILE* 的指针变量指向该文件，也相当于建立了指 针和文件的关系。
    ANSIC 规定使用 fopen 函数来打开文件， fclose 来关闭文件

     

     

     

     

     

     打开方式如下：

    实例代码：

    1. #include 
    2. int main()
    3. {
    4. 	FILE* p;
    5. 	p = fopen("test.txt", "w");
    6. 	if (p != NULL)
    7. 	{
    8. 		fputs("hello world", p);
    9. 		//关闭文件
    10. 		fclose(p);
    11. 	}
    12.  
    13. 	return 0;
    14. }

     

     

     

    四. 文件的顺序读写 

    所有顺序读写函数：

      

    fputs

    写入字符串文本行输出函数（输出流）： 

    1. #include 
    2. #include 
    3. #include
    4. int main()
    5. {
    6. 	FILE* p;
    7. 	p = fopen("test.txt", "w");
    8. 	if (p == NULL)
    9. 	{
    10. 		printf("%d", strerror(errno));
    11. 	}
    12. 	if (p != NULL)
    13. 	{
    14. 		//fputs适用于所有输出流，即写到文件中去
    15. 		fputs("hello world", p);
    16. 		//关闭文件
    17. 		fclose(p);
    18. 	}
    19.  
    20. 	return 0;
    21. }

     

     

     fgetc

    字符读取字符输入函数（输入流）

    1. #include 
    2. #include 
    3. #include
    4. int main()
    5. {
    6. 	FILE* p;
    7. 	p = fopen("test.txt", "r");
    8. 	if (p == NULL)
    9. 	{
    10. 		printf("%d", strerror(errno));
    11. 		return 1;
    12. 	}
    13. 	if (p != NULL)
    14. 	{
    15. 		//fputs适用于所有输出流，即写到文件中去
    16. 		int c=fgetc(p);
    17. 		printf("%c", c);
    18. 		//关闭文件
    19. 		fclose(p);
    20. 	}
    21.  
    22. 	return 0;
    23. }

     

    返回类型为 int 以适应特殊值 EOF，这表示失败.基于此，我们可以循环输出：

    1. #include 
    2. #include 
    3. #include
    4. int main()
    5. {
    6. 	FILE* p;
    7. 	p = fopen("test.txt", "r");
    8. 	if (p == NULL)
    9. 	{
    10. 		printf("%d", strerror(errno));
    11. 		return 1;
    12. 	}
    13. 	if (p != NULL)
    14. 	{
    15. 		//fputs适用于所有输出流，即写到文件中去
    16. 		int c = 0;
    17. 		while ((c = fgetc(p)) != EOF)
    18. 		{
    19. 			printf("%c\n", c);
    20. 		}
    21. 		
    22. 		//关闭文件
    23. 		fclose(p);
    24. 	}
    25.  
    26. 	return 0;
    27. }

     

     

     对于fputs而言，会清除之前的内容。如果想保留之前内容的话，我们可以用"a"追加来进行相关操作：

    1. #include 
    2. #include 
    3. #include
    4. int main()
    5. {
    6. 	FILE* p;
    7. 	p = fopen("test.txt", "a");
    8. 	if (p == NULL)
    9. 	{
    10. 		printf("%d", strerror(errno));
    11. 		return 1;
    12. 	}
    13. 	if (p != NULL)
    14. 	{
    15. 		//fputs适用于所有输出流，即写到文件中去
    16. 		fputs("hellohello", p);
    17. 		
    18. 		//关闭文件
    19. 		fclose(p);
    20. 	}
    21.  
    22. 	return 0;
    23. }

     

    fgets

     读一行数据文本输入流

     

    1. #include 
    2. #include 
    3. #include
    4. int main()
    5. {
    6. 	FILE* p;
    7. 	p = fopen("test.txt", "r");
    8. 	if (p == NULL)
    9. 	{
    10. 		printf("%d", strerror(errno));
    11. 		return 1;
    12. 	}
    13. 	if (p != NULL)
    14. 	{
    15. 		char a[100] = { 0 };
    16. 		//fputs适用于所有输出流，即写到文件中去
    17. 		fgets(a,5,p);
    18. 		printf("%s\n", a);
    19. 		//关闭文件
    20. 		fclose(p);
    21. 	}
    22.  
    23. 	return 0;
    24. }

     

     

    读5个数据，真正读到的才4个，还有一个’\0’！！！

    当然，对于报错的信息strerror我们可以用perror来替换（这里为了演示效果，我把test.txt文件删除了）

    1. #include 
    2. #include 
    3. #include
    4. int main()
    5. {
    6. 	FILE* p;
    7. 	p = fopen("test.txt", "r");
    8. 	if (p == NULL)
    9. 	{
    10. 		//printf("%s\n", strerror(errno));
    11. 		perror("fopen");
    12. 		return 1;
    13. 	}
    14. 	if (p != NULL)
    15. 	{
    16. 		char a[100] = { 0 };
    17. 		//fputs适用于所有输出流，即写到文件中去
    18. 		fgets(a,5,p);
    19. 		printf("%s\n", a);
    20. 		//关闭文件
    21. 		fclose(p);
    22. 	}
    23.  
    24. 	return 0;
    25. }

     

    为了刚好的认识fprintf格式化输出函数我们介绍一下流

    任何一个C程序，只要运行起来就会默认打开3个流：
    FILE* stdin - 标准输入流（键盘）
    FILE* stdout - 标准输出流（屏幕）
    FILE* stderr - 标准错误流（屏幕）
    而文件需要打开文件才会打开流
    FILE* P,p相当于流，返回类型为FILE*P

    fprintf

    格式化输出输出流

     这里我们可以和printf函数进行比较

     FILE*stream指的是流

    1. #include
    2. struct S
    3. {
    4. 	char arr[10];
    5. 	int age;
    6. 	float score;
    7. };
    8. int main()
    9. {
    10. 	struct S s = { "zhangsan",25,50.5f };
    11.  
    12. 	FILE* pf = fopen("test.txt", "w");
    13. 	if (pf == NULL)
    14. 	{
    15. 		perror("fopen");
    16. 	}
    17. 	fprintf(pf, "%s %d %f", s.arr, s.age, s.score);
    18.  
    19. 	fclose(pf);
    20. 	pf = NULL;
    21. 	return 0;
    22. }

     

    fscanf 

    格式化输入函数

    同理和scanf做对比

     

     

    1. #include
    2. struct S
    3. {
    4. 	char arr[10];
    5. 	int age;
    6. 	float score;
    7. };
    8. int main()
    9. {
    10. 	struct S s = { 0 };
    11.  
    12. 	FILE* pf = fopen("test.txt", "r");
    13. 	if (pf == NULL)
    14. 	{
    15. 		perror("fopen");
    16. 	}
    17. 	fscanf(pf, "%s %d %f", s.arr, &(s.age), &(s.score));
    18. 	printf("%s %d %f\n", s.arr, s.age, s.score);
    19.  
    20. 	fclose(pf);
    21. 	pf = NULL;
    22. 	return 0;
    23. }

     

    那用fprintf打印到屏幕上去呢？

    1. struct S
    2. {
    3. 	char arr[10];
    4. 	int age;
    5. 	float score;
    6. };
    7. int main()
    8. {
    9. 	struct S s = {0};
    10.  
    11. 	FILE* pf = fopen("test.txt", "r");
    12. 	if (pf == NULL)
    13. 	{
    14. 		perror("fopen");
    15. 	}
    16. 	fscanf(pf, "%s %d %f", s.arr, &(s.age), &(s.score));
    17. 	fprintf(stdout,"%s %d %f\n",s.arr,s.age,s.score);
    18.  
    19. 	fclose(pf);
    20. 	pf = NULL;
    21. 	return 0;
    22. }

     

     

    至此，前面我们学的函数都是文本，那对于二进制的呢

    fwrite

    二进制输出

     

     

     

     

    1. #include
    2. struct S
    3. {
    4. 	char arr[10];
    5. 	int age;
    6. 	float score;
    7. };
    8. int main()
    9. {
    10. 	struct S s = { "zhangsan",25,50.5f };
    11. 	//以二进制形式写到文件中
    12. 	FILE* pf = fopen("test.txt", "w");
    13. 	if (pf == NULL)
    14. 	{
    15. 		perror("fopen");
    16. 		return 1;
    17. 	}
    18. 	//二进制的方式写
    19. 	fwrite(&s, sizeof(struct S), 1, pf);
    20.  
    21.  
    22. 	fclose(pf);
    23. 	pf = NULL;
    24. }

     

    read

    二进制输入f

    1. struct S
    2. {
    3. 	char arr[10];
    4. 	int age;
    5. 	float score;
    6. };
    7. int main()
    8. {
    9. 	struct S s = {0};
    10. 	//以二进制形式写到文件中
    11. 	FILE* pf = fopen("test.txt", "rb");
    12. 	if (pf == NULL)
    13. 	{
    14. 		perror("fopen");
    15. 		return 1;
    16. 	}
    17. 	//二进制的方式读
    18. 	fread(&s, sizeof(struct S), 1, pf);
    19. 	printf("%s %d %f", s.arr, s.age, s.score);
    20. 	fclose(pf);
    21. 	pf = NULL;
    22. }

     

     

    scanf：是针对标准输入的格式化输入语句

    printf:是针对标准输出的格式化输出语句

    fscanf:是针对所有输入流的格式化输入语句（键盘和文件）

    fgetc:是针对所有输入流的格式化输入语句（键盘和文件）

    fgets:是针对所有输入流的格式化输入语句（键盘和文件）

    fprintf:是针对所有输出流的格式化输出语句（屏幕和文件）

    fput:是针对所有输出流的格式化输出语句（屏幕和文件）

    fputs:是针对所有输出流的格式化输出语句（屏幕和文件）

    sprintf:

     

    1. #include
    2. struct S
    3. {
    4. 	char arr[10];
    5. 	int age;
    6. 	float score;
    7. };
    8.  
    9.  
    10. int main()
    11. {
    12. 	struct S s = { "zhangsan",20,55.5f };
    13. 	char buf[100] = { 0 };
    14. 	sprintf(buf, "%s %d %f", s.arr, s.age, s.score);
    15.  
    16. 	printf("%s\n", buf);
    17. 	return 0;
    18. }

     

     sscanf

     

    1. #include
    2. struct S
    3. {
    4. 	char arr[10];
    5. 	int age;
    6. 	float score;
    7. };
    8.  
    9.  
    10. int main()
    11. {
    12. 	struct S s = { "zhangsan",20,55.5f };
    13. 	struct S tmp = { 0 };
    14. 	char buf[100] = { 0 };
    15. 	sprintf(buf, "%s %d %f", s.arr, s.age, s.score);
    16.  
    17. 	printf("%s\n", buf);
    18. 	//从字符串buf中获取一个格式化的数据到tmp中
    19. 	sscanf(buf, "%s %d %f", tmp.arr, &(tmp.age), &(tmp.score));
    20. 	printf("格式化：%s %d %f\n", tmp.arr, tmp.age, tmp.score);
    21. 	return 0;
    22. }

     

     

     结语：

    每个人的成长都是能力和想要得到的东西，不断匹配的过程，当你的才华和欲望不匹配时，你就该静下心来学习了，如果小编的总结能对你有所帮助，希望小伙伴们三连加关注哦，你的支持是小编创作的最大动力。

  • 相关阅读:
    企业微信 API 接口调用教程：图文详解企业微信 API 的使用方法
    【FPGA教程案例63】硬件开发板调试3——vio虚拟IO核的应用
    windows系统使用docker-compose
    【C++】模板进阶 —— 非类型模板参数 | 特化 | 模板的分离编译
    Vue组件的八个钩子函数
    JavaSE之可变参数和泛型
    学习 PostCSS 以及使用
    ESP32通过ali的C LINK4.0接入aliyun阿里云
    机器学习模型结果可信度基础理论
    基于MFC的串口通信
  • 原文地址：https://blog.csdn.net/weixin_67900732/article/details/125897024