• C语言文件操作（超详细版）

    目录

    什么是文件

    ✨文件分类

      程序文件

      数据文件

    文件的使用

    ✨文件指针

    文件指针的使用

    ✨文件的打开和关闭

    文件的使用方式

    ✨文件的顺序读写

    1.写入一个字符

    2.读取一个字符

    3.连续每次读取一个字符

    4.覆盖并写入一行数据

    5.读取指定长度的数据

    6.将结构体信息写入文件中

    7.读取文件信息到结构体变量中

    8.二进制写入文件

    9.读取二进制文件信息

    10.sscanf()函数、sprintf()函数

    文件的随机读写

    ✨fseek()函数

    ✨ftell函数()

    ✨ rewind()函数

    二进制文件和文本文件

    文件读取结束判定

    ✨feof()函数

    文本文件的判断

    二进制文件的判断

    📌————本章重点————📌

    🔗文件指针

    🔗文件的顺序读写

    🔗文件的随机读写

    🔗文件读取结束判定


     ✨————————————✨

    什么是文件

            与普通文件载体不同，文件是以硬盘为载体存储在计算机上的信息集合，文件可以是文本文档、图片、程序等等。文件通常具有点+三个字母的文件扩展名，用于指示文件类型（例如，图片文件常常以KPEG格式保存并且文件扩展名为.jpg）。

            将数据放入文件中，相比代码程序中堆栈上的数据，其优点在于可以随时做到需要时添加、舍弃时删除，数据可以持久化。

    文件分类：

            文件一般讲两种：程序文件和数据文件；

      程序文件：

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

      数据文件：

            包括程序运行时所读写的数据。本篇所涉及的就是数据文件。

    文件的使用

    文件的操作一般分三步：1.打开文件；2.读/写；3.关闭文件；

    文件指针

            想要对文件进行操作，“文件指针”就是一个关键桥梁（亦名：文件类型指针）；                

            底层原理：每个被使用的文件，都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如：文件名、文件状态、文件位置等），这些信息被保存到一个结构体中，系统为其声明为FILE，每当打开一个文件的时候，系统就会根据情况自动创建一个FILE结构的变量，并且通过FILE*的指针来维护这个结构。

    文件指针的使用：

        FILE* pf;

    定义一个文件指针变量pf，它可以指向某个文件的文件信息区，通过其即可访问到该文件。

    文件的打开和关闭

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

    • fopen() —— 打开文件；
      • FILE * fopen ( const char * filename, const char * mode );
    • fclose() —— 关闭文件；
      • int fclose ( FILE * stream );

    文件的使用方式：

    按常用序：

    使用方式作用 如果文件不存在
    "r"（只读）为了输入数据，打开一个已经存在的文本文件出错                
    "w"（只写）为了输出数据，打开一个文本文件建立一个新的文件
    "a"（追加）向文本文件添加数据建立一个新的文件
    "rb"（只读）为了输入数据，打开一个二进制文件出错
    "wb"（只写）为了输出数据，打开一个二进制文件建立一个新的文件
    "ab"（追加）向一个二进制文件尾添加数据出错
    "r+"（读写）为了读和写，打开一个文本文件出错
    "w+"（读写）为了读和写，建立一个新的文本文件建立一个新的文件
    "a+"（读写）打开一个文本文件，在文件尾进行读写建立一个文件
    "rb+"（读写）为了读和写，打开一个二进制文件出错
    "wb+"（读写）为了读和写，建立一个新的二进制文件建立一个新的文件
    "ab+"（读写）打开一个二进制文件，在文件尾进行读写建立一个新的文件

    文件的顺序读写

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

    以上结合起来实例：

    1. #include
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	FILE* pf= fopen("test.txt", "w+");
    8. 	if (pf == NULL)
    9. 	{
    10. 		printf("%s\n", strerror(errno));
    11. 		return;
    12. 	}
    13. 	//输入一个字符
    14. 	fputc('a', pf);
    15. 	//用完关闭文件
    16. 	fclose(pf);
    17. 	pf = NULL;
    18.  
    19. 	return 0;
    20. }

    如图示：在源文件所在目录下，原本没有test.txt文件，是w+创建了这个新的文件，并写入一个字符a 

    1.写入一个字符：

    1. //写文件    
    2.     fputc('a', pf);

    2.读取一个字符：

    1. 	//读取一个字符
    2. 	int ch = fgetc(pf);
    3. 	if (ch != EOF)
    4. 	{
    5. 		printf("%c\n", ch);
    6. 	}

    3.连续每次读取一个字符：

    1. 	//文件中有abcdefg
    2.  
    3. 	int ch = fgetc(pf);
    4. 	printf("%c\n", ch);	//a
    5. 	ch = fgetc(pf);
    6. 	printf("%c\n", ch);	//b
    7. 	ch = fgetc(pf);
    8. 	printf("%c\n", ch);	//c
    9. 	ch = fgetc(pf);
    10. 	printf("%c\n", ch);	//d

    4.覆盖并写入一行数据：

    	fputs("hello world", pf);

    注意：这里fputs函数虽然是整行写入，但会覆盖掉原始数据、

    5.读取指定长度的数据：

    1.     //定一一个数组
    2. 	char arr[10] = { 0 };
    3. 	fgets(arr, 5, pf);    //将所读取的数据放入arr中
    4. 	printf("%s\n", arr);

    6.将结构体信息写入文件中：

    这里的结构体信息就是格式化的，那么就需要fprintf()函数了

    1. #include
    2.  
    3. typedef struct S
    4. {
    5. 	char name[10];
    6. 	int age;
    7.  
    8. }Peo;
    9. int main()
    10. {
    11. 	FILE* pf = fopen("test.txt", "w");
    12.  
    13. 	if (pf != NULL)
    14. 	{
    15. 		Peo p = { "zhangsan", 18 };
    16. 		fprintf(pf, "%s %d\n", p.name, p.age);
    17.  
    18. 		fclose(pf);
    19. 		pf = NULL;
    20. 	}
    21.  
    22. 	return 0;
    23. }

    7.读取文件信息到结构体变量中：

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

    8.二进制写入文件：

    • size_t fwrite( const void *buffer, size_t size, size_t count, FILE *stream );
    1. #include
    2. #include
    3. #include
    4.  
    5. typedef struct S
    6. {
    7. 	char name[10];
    8. 	int age;
    9.  
    10. }Peo;
    11. int main()
    12. {
    13. 	FILE* pf = fopen("test.txt", "wb+");
    14.  
    15. 	if (pf != NULL)
    16. 	{
    17. 		Peo p = { "lisi", 19};
    18.  
    19. 		fwrite(&p, sizeof(Peo), 1, pf);
    20.  
    21. 		fclose(pf);
    22. 		pf = NULL;
    23. 	}
    24.  
    25. 	return 0;
    26. }

    9.读取二进制文件信息：

    • size_t fread( void *buffer, size_t size, size_t count, FILE *stream );

    1. #include
    2.  
    3. typedef struct S
    4. {
    5. 	char name[10];
    6. 	int age;
    7.  
    8. }Peo;
    9. int main()
    10. {
    11. 	FILE* pf = fopen("test.txt", "rb+");
    12.  
    13. 	if (pf != NULL)
    14. 	{
    15. 		Peo p = { 0 };
    16.  
    17. 		fread(&p, sizeof(Peo), 1, pf);
    18.  
    19. 		printf("%s %d\n", p.name, p.age);
    20.  
    21. 		fclose(pf);
    22. 		pf = NULL;
    23. 	}
    24.  
    25. 	return 0;
    26. }

    10.sscanf()函数、sprintf()函数：

    这两个函数虽然和文件操作关系不大，但是容易与文件操作函数混淆；

    • sscanf()函数：
    • int sscanf( const char *buffer, const char *format [, argument ] ... );
    • 将一个字符串转化为格式化数据；
    1. #include
    2.  
    3. typedef struct S
    4. {
    5. 	char name[10];
    6. 	int age;
    7.  
    8. }Peo;
    9. int main()
    10. {
    11. 	//定义一个字符串
    12. 	char buffer[] = { "zhansan 19" };
    13. 	//定义一个结构但不赋值
    14. 	Peo p = { 0 };
    15.  
    16. 	sscanf(buffer, "%s %d", p.name, &p.age);
    17.  
    18. 	return 0;
    19. }

    • sprintf()函数：

    • int sprintf( char *buffer, const char *format [, argument] ... );

    • 将一个格式化数据转化为字符串；

    1. #include
    2.  
    3. typedef struct S
    4. {
    5. 	char name[10];
    6. 	int age;
    7.  
    8. }Peo;
    9. int main()
    10. {	
    11. 	//定义一个结构
    12. 	Peo p = { "zhangsan",19};
    13. 	//定义一个字符串
    14. 	char buffer[50] = { 0 };
    15.  
    16. 	sprintf(buffer, "%s %d\n", p.name, p.age);
    17.  
    18. 	return 0;
    19. }

    文件的随机读写

    所谓的随机读写，其实就是指定我们想要读写的位置。

    fseek()函数：

    • 该函数可以从定位位置的偏移量处开始读写；
    • int fseek( FILE *stream, long offset, int origin );
                           文件流          偏移量    起始位置 
    • 返回值：
    1. 如果成功，fseek返回0；
    2. 否则，它返回一个非零值；
    3. 在无法查找的设备上，返回值未定义；        

     三种定位指针：

     使用实例：

    1. #include
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	FILE* pf = fopen("test.txt", "r");
    8.  
    9. 	if (pf == NULL)
    10. 	{
    11. 		printf("%s\n", strerror(errno));
    12. 		return;
    13. 	}
    14. 	//开始多次读取
    15. 	//定位指针：比如要读取从头开始向后偏移 2 个单位的一个字符
    16. 	fseek(pf, 2, SEEK_SET);
    17. 	int ch = fgetc(pf);
    18. 	printf("%c\n", ch);
    19.  
    20. 	//第二次读取：要拿到当前文件指针所处位置向后偏移5个单位的字符
    21. 	fseek(pf, 5, SEEK_CUR);
    22. 	ch = fgetc(pf);
    23. 	printf("%c\n", ch);
    24.  
    25. 	//第三次读取：要拿到文件流末尾向前偏移8个单位的一个字符
    26. 	fseek(pf, -8, SEEK_END);
    27. 	ch = fgetc(pf);
    28. 	printf("%c\n", ch);
    29.  
    30. 	fclose(pf);
    31. 	pf = NULL;
    32.  
    33. 	return 0;
    34. }

    特别说明：

            在每使用完一次fseek函数后，文件指针会自动向后移动一位：

    ftell函数()：

    • 该函数可以返回文件指针相对于起始位置的偏移量；
    • long int ftell ( FILE * stream );

    使用实例：

            我们直接在上一段代码的基础上加上ftell()函数即可直观得到每次文件指针所处的位置：

     rewind()函数：

    • 让文件指针回到文件初始位置；
    • void rewind ( FILE * stream );

    使用实例： 

    二进制文件和文本文件

    我们知道数据在内存中是以二进制形式存储的，对于文件而言：如果不加转换直接输出到外存就是二进制文件；如果要在外存上以ASCII码形式存储，就需要提前转换最后以ASCII码值形式存储的文件就是文本文件。

    对于字符，一律使用ASCII码形式存储，但对于数值型数据，即可以使用ASCII码存储也可以使用二进制形式存储。

    举例：

    数字10000的两种存储形式：

    二进制文件：

    文本文件：

    首先将10000分成'1','0','0','0','0', 这五个字符，用每个字符对应的ASCII码值进行转换：

     

     由此可见：对于10000在数，如果以二进制形式存储占用4个字节，如果以ASCII码存储占用5个字节。试想：那对于数字1呢？

    显而易见，二进制文件存储和文本文件存储对不同范围的数字可以做到节省空间。

    对二进制文件深入理解：

    1. #include
    2.  
    3. int main()
    4. {
    5. 	FILE* pf = fopen("test.txt", "wb");
    6. 	int a = 10000;
    7.  
    8. 	if (pf != NULL)
    9. 	{
    10. 		fwrite(&a, 4, 1, pf);
    11.  
    12. 		fclose(pf);
    13. 		pf = NULL;
    14. 	}
    15.  
    16. 	return 0;
    17. }

    对于上面这段代码，我们知道是将数值10000放入了test.txt文件中，但我们无法直接看到它在文件中的真实值，于是使用vs的二进制编辑器即可查看：


    文件读取结束判定

    feof()函数：

    该函数被许多人错误用来判断文件是否读取结束，其实它的作用是判断文件读取结束的原因；

    文件读取结束有两种情况：1.读取过程中出现异常； 2.读取到文件末尾；

    要找出文件读取是哪个原因，就分为以下情况：

    文本文件：

    • 如果用 fgetc() 读取，要判断 feof() 的返回值是否为EOF；
    • 如果用 fgets() 读取，要判断 feof() 的返回值是否为NULL(0)；

    二进制文件：

            都是使用 fread() 读取，要判断其返回值与指定读取个数的大小，如果小于实际要读的个数，就说明发生读取异常，如果等于实际要读的个数，就说明是因读取成功而结束；

    对于读取异常的判断，我们考虑判断 ferror() 函数的返回值：

    1. 若ferrror()为真——异常读取而结束；
    2. 若feof()为真——正常读取到尾而结束；

    文本文件的判断：

    1. #include
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	FILE* pf = fopen("test.txt", "r");
    8.  
    9. 	if (pf == NULL)
    10. 	{
    11. 		perror("fopen is failed !");
    12. 		return;
    13. 	}
    14. 	int c = 0;
    15. 	//由于要检查EOF——EOF本质是0——所以是int
    16. 	while (c = fgetc(pf) != EOF)
    17. 	{
    18. 		putchar(c);
    19. 	}
    20. 	//直到while不执行了—读取结束了—判断是什么原因结束的
    21. 	if (ferror(pf))
    22. 	{
    23. 		printf("读取中出现错误\n");
    24. 	}
    25. 	else if (feof(pf))
    26. 	{
    27. 		printf("读取到文件尾\n");
    28. 	}
    29.  
    30. 	fclose(pf);
    31. 	pf = NULL;
    32.  
    33. 	return 0;
    34. }

    二进制文件的判断：

    1. #include
    2. #include
    3. #include
    4.  
    5. int main()
    6. {
    7. 	FILE* pf = fopen("test.txt", "rb");
    8. 	int arr[5] = { 0 };
    9.  
    10. 	if (pf == NULL)
    11. 	{
    12. 		return;
    13. 	}
    14.  
    15. 	size_t num = fread(arr, sizeof(int), 5, pf);
    16.  
    17. 	if (num == 5)
    18. 	{
    19. 		//说明全部读取成功
    20. 		printf("Array read successfully\n");
    21. 	}
    22. 	else
    23. 	{
    24. 		//说明读取不够指定长度—判断是什么原因
    25. 		if (ferror(pf))
    26. 		{
    27. 			printf("读取中出现错误\n");
    28. 		}
    29. 		else if (feof(pf))
    30. 		{
    31. 			printf("读取到文件尾\n");
    32. 		}
    33. 	}
    34.  
    35. 	fclose(pf);
    36. 	pf = NULL;
    37.  
    38. 	return 0;
    39. }

  • 相关阅读:
    QT中文乱码解决方案与乱码的原因
    【Android】 屏幕录制screenrecord为什么这么快？
    正则表达式 || 遇到字符串里面有（） 就在括号后面换行
    解决java -jar启动项目以及日志输出相关问题
    用 Python实现Python解释器
    尚硅谷大数据项目《在线教育之离线数仓》笔记008
    git仓库-客户端软件安装配置过程
    「在 Kubernetes 上运行 Pgpool-Il」实现 PostgreSQL 查询(读)负载均衡和连接池
    Go数据结构队列
    算法与设计分析--实验一
  • 原文地址：https://blog.csdn.net/m0_65190367/article/details/126682477