#include <stdio.h>
int main()
{int a = 10000;FILE* pf = fopen("test.txt", "wb");fwrite(&a, 4, 1, pf);//⼆进制的形式写到⽂件中fclose(pf);pf = NULL;return 0;}

ps：二进制文件本身的内容就不是文字，用文本工具打开自然会是乱码

ps：就是说二进制的程序文件可以在源文件下用二进制编辑器的打开方式去实现。

3.1  这边用二进制编译器输出时为啥没有ox？

ox 并不是二进制或十六进制数据本身的一部分，它只是人类为了区分进制而加上的 '标记'。

4. 文件的打开和关闭

4.1 流和标准流

4.1.1 流

4.1.2 标准流

1. stdin - 标准输⼊流，在⼤多数的环境中从键盘输⼊，scanf函数就是从标准输⼊流中读取数据。
2. stdout - 标准输出流，⼤多数的环境中输出⾄显⽰器界⾯，printf函数就是将信息输出到标准输出流中。
3. stderr - 标准错误流，⼤多数环境中输出到显⽰器界⾯。

4.2 文件指针

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

4.3 文件的打开和关闭

 //打开⽂件FILE * fopen ( const char * filename, const char * mode );//关闭⽂件int fclose ( FILE * stream );

1. 权限问题
2. 路径要对

/* fopen fclose example */
#include <stdio.h>
int main ()
{FILE * pFile;//打开⽂件pFile = fopen ("myfile.txt","w");//⽂件操作if (pFile!=NULL){fputs ("fopen example",pFile);//关闭⽂件fclose (pFile);}return 0;
}

4.3.1 文件路径中起始点的解析

假设程序当前运行的目录是 C:\A\B\C（即当前路径在 C 文件夹里），来看两个例子的区别：

例子1：.\\..\\..\\test.txt（1个 . + 2个 ..）

    •    解析步骤：

    1.    . → 从当前目录 C:\A\B\C 开始

    2.    第一个 .. → 跳至上一级 C:\A\B

    3.    第二个 .. → 再跳至上一级 C:\A

    4.    最终找 test.txt → 实际路径是 C:\A\test.txt

例子2：..\\..\\..\\test.txt（3个 ..）

    •    解析步骤：

    1.    从当前目录 C:\A\B\C 开始（默认起点，无需 .）

    2.    第一个 .. → 跳至 C:\A\B

    3.    第二个 .. → 跳至 C:\A

    4.    第三个 .. → 再跳至 C:\（A 文件夹的上一级是根目录 C:\）

    5.    最终找 test.txt → 实际路径是 C:\test.txt

核心区别：

    •    例子1的路径最终定位到 C:\A\test.txt（向上跳2级）

    •    例子2的路径最终定位到 C:\test.txt（向上跳3级）

跳转的层级不同，找到的文件位置自然不一样～

4.3.2  文件关闭和free有点相似

你混淆的点其实和「动态内存管理」「资源释放」的共性与差异有关，这几个概念确实容易串在一起，咱们分清楚核心逻辑就好了：

一、fclose() + 置空指针 与 free() + 置空指针的「异曲同工」之处

两者本质都是 “释放资源后避免误用”，逻辑完全一致：

    •    free(p)：释放动态分配的内存（比如malloc申请的），但指针p仍保留原地址（变成野指针）。如果之后再用p读写，会访问无效内存，导致错误。

    •    fclose(fp)：释放文件相关的系统资源（文件描述符、缓冲区等），但指针fp仍保留原地址（变成野指针）。如果之后再用fp操作文件，会访问已回收的资源，导致错误。

所以两者都需要在释放后 手动置空指针（p = NULL; 或 fp = NULL;），目的是把“隐藏的错误”变成“明确的空指针错误”，方便调试。

二、为什么有人会误认为“不置空会让程序一直运行”？

可能和 “内存泄漏”的概念混淆了。动态内存管理中：

    •    如果用malloc申请了内存，却忘记free，会导致 内存泄漏（系统内存被持续占用，无法回收）。

    •    对于长期运行的程序（比如服务器），内存泄漏累积到一定程度，可能导致系统内存不足，甚至程序崩溃（但不是“程序一直运行停不下来”，而是“运行中出问题”）。

但注意：

    •    内存泄漏的核心是“资源没释放”，和指针是否置空无关（哪怕free后没置空，资源也已经释放了，不会泄漏）。

    •    程序是否“停不下来”，只看代码逻辑（比如while(1)死循环），和内存/文件资源是否释放完全无关。

5. 文件的顺序读写

5.1 顺序读写函数介绍

5.2.1 scanf/fscanf/sscanf 的区别

• scanf

功能：从标准输入流（通常是键盘）读取格式化数据。

原型：int scanf(const char *format, ...);

示例：

#include <stdio.h>int main() 
{int num;printf("请输入一个整数: ");scanf("%d", &num);printf("你输入的整数是: %d\n", num);return 0;
}

说明：程序运行时，会等待用户通过键盘输入数据，scanf 按照指定的格式 %d 读取整数并存储到变量 num 中。

• fscanf

功能：从指定的文件流中读取格式化数据。

原型：int fscanf(FILE *stream, const char *format, ...);

示例：

#include <stdio.h>int main() 
{FILE *fp;int num;fp = fopen("test.txt", "r");if (fp != NULL) {fscanf(fp, "%d", &num);printf("从文件中读取的整数是: %d\n", num);fclose(fp);}return 0;
}

• 说明：假设 test.txt 文件中存储了一个整数，fscanf 从打开的文件流 fp 中，按照 %d 的格式读取整数。它适用于从文件中读取特定格式的数据，而不是从标准输入读取。

• sscanf

功能：从字符串中读取格式化数据。

原型：int sscanf(const char *str, const char *format, ...);

示例：

#include <stdio.h>int main() 
{char str[] = "123";int num;sscanf(str, "%d", &num);printf("从字符串中读取的整数是: %d\n", num);return 0;
}

• 说明：sscanf 从给定的字符串 str 中，按照 %d 的格式解析出整数，并存储到变量 num 中。它常用于从已有的字符串中提取特定格式的数据。

5.2.2  printf/fprintf/sprintf 的区别

• printf

功能：将格式化的数据输出到标准输出流（通常是屏幕）。

原型：int printf(const char *format, ...);

示例：

#include <stdio.h>int main()
{int num = 10;printf("整数的值是: %d\n", num);return 0;
}

• 说明：printf 按照指定的格式 %d 将变量 num 的值输出到屏幕上。

• fprintf

功能：将格式化的数据输出到指定的文件流中。

原型：int fprintf(FILE *stream, const char *format, ...);

示例：

#include <stdio.h>int main() 
{FILE *fp;int num = 20;fp = fopen("output.txt", "w");if (fp != NULL) {fprintf(fp, "整数的值是: %d\n", num);fclose(fp);}return 0;
}

• 说明：fprintf 将格式化的数据输出到打开的文件流 fp 指向的文件中，这里是将包含整数 num 值的字符串写入到 output.txt 文件。

• sprintf

功能：将格式化的数据输出到字符串中。

原型：int sprintf(char *str, const char *format, ...);

示例：

#include <stdio.h>int main() 
{char result[50];int num = 30;sprintf(result, "整数的值是: %d\n", num);printf("生成的字符串是: %s", result);return 0;
}

说明：sprintf 按照指定的格式将数据写入到字符数组 result 中，而不是直接输出到屏幕或文件，之后可以对这个字符串进行进一步的处理，比如传递给其他函数 。

5.3 我对内存和文件的总结

假设写了一个简单的程序：

#include <stdio.h>
int main() 
{FILE *f = fopen("test.txt", "r"); // 用r模式打开文件int num_from_file;fscanf(f, "%d", &num_from_file); // 从文件读数据（比如读到123）fclose(f); // 关闭文件int num_from_keyboard;printf("请输入一个数字：");scanf("%d", &num_from_keyboard); // 从键盘读数据（比如输入456）int result = num_from_file + num_from_keyboard; // 计算123+456printf("结果是：%d", result); // 屏幕显示589return 0;
}

这里的关键：

    •    test.txt是外部文件，里面的123是“长期存储”的（关了电脑也在）。

    •    程序运行时，会把123从文件读到num_from_file这个变量里——这个变量存在内存里（临时存储，程序结束就消失了）。

    •    你从键盘输入的456，会存在num_from_keyboard这个变量里——也在内存里，和文件没关系。

总结来了：

1.  r模式的核心：只允许“读取文件内容”，绝对不能改文件本身（文件里的123永远是123）。
2.  程序的临时变量：键盘输入的数字、计算过程中的数据，都存在程序的内存里（像局部变量这种），是程序自己的“临时工作区”，和被打开的文件没关系。   
3. 文件和程序是分开的：用r模式打开文件，只是“借用”文件的内容来用，程序后续的代码（比如输入、计算、显示）都是服务于程序本身，不会碰文件一根毫毛。

简单说：r模式下，文件是“只读的素材”，程序是“处理素材的工具”，工具自己怎么折腾（临时变量、输入）都不影响素材本身。

6. 文件的随机读写

6.1 fseek

int fseek ( FILE * stream, long int offset, int origin );

例子：

/* fseek example */
#include <stdio.h>
int main ()
{FILE * pFile;pFile = fopen ( "example.txt" , "wb" );fputs ( "This is an apple." , pFile );fseek ( pFile , 9 , SEEK_SET );fputs ( " sam" , pFile );fclose ( pFile );return 0;
}

例子2：

int fseek(FILE *stream, long offset, int origin);

参数说明：

• stream：文件指针（如 FILE *fp）
• offset：偏移量（字节数），可正可负（正数向后移，负数向前移）
• origin：起始点（从哪里开始计算偏移），有 3 种取值：
  • SEEK_SET：从文件开头开始（值为 0）
  • SEEK_CUR：从当前位置开始（值为 1）
  • SEEK_END：从文件末尾开始（值为 2）

// 假设文件已打开（fp）
fseek(fp, 100, SEEK_SET);  // 移动到文件第100个字节处（从开头数）
fseek(fp, 50, SEEK_CUR);   // 从当前位置再向后移动50字节
fseek(fp, -30, SEEK_END);  // 从文件末尾向前移动30字节（定位到倒数第30字节）

6.2 ftell

long int ftell ( FILE * stream );

/* ftell example : getting size of a file */
#include <stdio.h>
int main ()
{FILE * pFile;long size;pFile = fopen ("myfile.txt","rb");if (pFile==NULL)perror ("Error opening file");else{fseek (pFile, 0, SEEK_END); // non-portablesize=ftell (pFile);fclose (pFile);printf ("Size of myfile.txt: %ld bytes.\n",size);}
return 0;
}

• 记录当前位置，方便后续回到该位置
• 计算文件大小（先定位到文件末尾，再用 ftell 获取偏移量）：

fseek(fp, 0, SEEK_END);  // 移动到文件末尾
long file_size = ftell(fp);  // 此时的偏移量就是文件总字节数

6.3 rewind

void rewind ( FILE * stream );

/* rewind example */
#include <stdio.h>
int main ()
{int n;FILE * pFile;char buffer [27];pFile = fopen ("myfile.txt","w+");for ( n='A' ; n<='Z' ; n++)fputc ( n, pFile);rewind (pFile);fread (buffer,1,26,pFile);fclose (pFile);buffer[26]='\0';printf(buffer);return 0;
}

区别：rewind 没有返回值，而 fseek 会返回 0（成功）或非 0（失败），可以判断操作是否成功。

6.4  三者总结

• fseek 是 "主动移动" 指针到任意位置
• ftell 是 "查询" 当前指针的位置
• rewind 是 "快速复位" 指针到开头

7. 文件读取结束的判定

7.1 被错误使用的 feof

• fgetc 判断是否为 EOF .
• fgets 判断返回值是否为 NULL .

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

#include <stdio.h>
#include <stdlib.h>int main(void)
{int c; // 注意：int，⾮char，要求处理EOFFILE* fp = fopen("test.txt", "r");if(!fp) {perror("File opening failed");return EXIT_FAILURE;}//fgetc 当读取失败的时候或者遇到⽂件结束的时候，都会返回EOFwhile ((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);
}

#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 handlingif (feof(fp))printf("Error reading test.bin: unexpected end of file\n");else if (ferror(fp)) {perror("Error reading test.bin");}}fclose(fp);
}

8. 文件缓冲区

8.1 考点一：缓冲区概念

#include <stdio.h>
#include <stdlib.h>int main() 
{FILE *fp;fp = fopen("test.txt", "w");if (fp == NULL) {perror("fopen");exit(EXIT_FAILURE);}// 向文件写入数据，此时数据先写入缓冲区fputs("Hello, File Buffer!", fp); // 程序结束前，缓冲区数据会自动写入磁盘fclose(fp); return 0;
}