• 文件操作(File Operations)

    目录

    文件操作：：

                        1.文件的定义

                        2.文件的打开和关闭

                        3.文件的顺序读写

                        4.文件的随机读写

                        5.文件读取结束的判定

                        6.文件缓冲区

    文件操作：：

    1.文件的定义

    文件的定义：

    在程序设计中，文件一般分为两种：程序文件和数据文件.

    程序文件：包括源文件(后缀为.c)，目标文件(windows环境后缀为.obj)，批处理文件(windows环境后缀为.bat)，可执行程序(后缀为.exe).

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

    使用文件的原因：

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

    文件名：

    一个文件要有一个唯一的文件标识，以便用户识别和引用.

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

    例：C：\ code \ test.txt

    为了方便起见，文件标识常被称为文件名.

    文本文件和二进制文件：

    根据数据的组织形式，数据文件被分为文本文件和二进制文件.

    文本文件：基于字符编码，常见编码有ASCII、UNICODE等，一般可以使用文本编辑器直接打开.

    二进制文件：数据在内存中以二进制的形式存储，如果不加转换的输出到外存就是二进制文件，数值10000在文本文件和二进制文件的存储方式如下：

    比如程序运行需要从中读取数据的文件或者输出内容的文件.
    test.c(内存)---(写数据(输出))-->文件，文件---(读数据(输入))-->test.c (内存).
    实际上，把内存的数据写到文件里叫写或者输出，把文件的数据读到内存里去叫读或者输入.

    注：在以前所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上.其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中，那么这里我们处理的就是磁盘上的文件.

    2.文件的打开和关闭

    文件指针

    在C语言中用一个指针变量指向一个文件，这个指针被称为文件指针.

    每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息(如文件的名字，文件状态及文件当前的位置等)，这些信息是保存在一个结构体变量中的，该结构体类型是由系统声明的，取名FILE，即FILE是系统使用typedef定义出来的有关文件信息的一种结构体类型，结构中含有文件名，文件状态和文件当前的位置信息等.

     不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异，每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节，一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更方便.

    FILE* pf;文件指针变量

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

    文件的打开和关闭

    文件的打开

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


    第一个参数的几种形式：

     第二个参数的几种形式(打开文件的方式)：

     注意：

            1.b是二进制模式的意思，b只有在Windows有效，而Linux用 r 和 rb 结尾是一样的.

            2.Unix和Linux下所有的文本文件行都是 \n 结尾，而Windows所有的文本文件行都是 \r\n 结尾

            3.在Windows平台下，以“文本”方式打开文件，不加b：

                    当读取文件的时候，系统会将所有的 “\r\n” 转换成 “\n”.

                    当写入文件的时候，系统会将 "\n" 转化成 "\r\n"写入.

                    以“二进制”方式打开文件，则读写 \n 都不会进行这样的转换.

            4.在Unix/Linux平台下，“文本”与“二进制”模式没有区别，“\r\n”作为两个字符原样输出.

    文件的关闭

    任何文件在使用后应该关闭.

    1.打开的文件会占用内存资源，如果总是打开不关闭，会消耗很多内存.

    2.一个进程同时打开的文件数是有限制的，超过最大同时打开文件数，再次调用fopen打开文件会失败.

    3.如果没有明确的调用 fclose 关闭打开的文件，那么程序在退出的时候，操作系统会统一关闭.

    1. #include
    2. #include
    3. int main()
    4. {
    5. 	FILE* pf = fopen("test.txt", "w");
    6. 	if (pf == NULL)
    7. 	{
    8. 		printf("%s\n", strerror(errno));
    9. 		return 1;
    10. 	}
    11. 	fclose(pf);
    12. 	pf = NULL;
    13. 	return 0;
    14. }

    3.文件的顺序读写

    按照字符读写文件fgetc、fputc

    写文件： 

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

    读文件：

    1. #include
    2. int main()
    3. {
    4. 	FILE* pf = fopen("test.txt", "r");
    5. 	if (pf == NULL)
    6. 	{
    7. 		printf("%s\n", strerror(errno));
    8. 		return 1;
    9. 	}
    10. 	//读文件
    11. 	//一次读取
    12. 	int ch = fgetc(pf);
    13. 	printf("%c\n", ch);
    14. 	//多次读取
    15. 	ch = 0;
    16. 	while ((ch = fgetc(pf)) != EOF)
    17. 	{
    18. 		printf("%c ", ch);
    19. 	}
    20. 	//关闭文件
    21. 	fclose(pf);
    22. 	pf = NULL;
    23. 	return 0;
    24. }

    文件结尾：

    在C语言中，EOF表示文件结束符(end of file)，在while循环中以EOF作为文件结束标志，这种以EOF作为文件结束标志的文件，必须是文本文件，在文本文件中，数据都是以字符的ASCII码值的形式存放，而ASCII码值的范围是0--127,不可能出现-1，因此可以用EOF作为文件结束标志.

    按照行读写文件： fgets、fputs

    写文件：

    1. #include
    2. int main()
    3. {
    4. 	FILE* pf = fopen("test.txt", "w");
    5. 	if (pf == NULL)
    6. 	{
    7. 		printf("%s\n", strerror(errno));
    8. 		return 1;
    9. 	}
    10. 	//写一行数据
    11. 	fputs("hello world", pf);
    12. 	fclose(pf);
    13. 	pf = NULL;
    14. 	return 0;
    15. }

    读文件：

    1. #include
    2. int main()
    3. {
    4. 	FILE* pf = fopen("test.txt", "r");
    5. 	if (pf == NULL)
    6. 	{
    7. 		printf("%s\n", strerror(errno));
    8. 		return 1;
    9. 	}
    10. 	//读一行数据
    11. 	char arr[20];
    12. 	fgets(arr, 6, pf);
    13. 	printf("%s\n", arr);
    14. 	fclose(pf);
    15. 	pf = NULL;
    16. 	return 0;
    17. }

    按照格式化文件fprintf、fscanf

    写文件：

    1. //写一个结构体数据
    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.0f };
    11. 	FILE* pf = fopen("test.txt", "w");
    12. 	if (pf == NULL)
    13. 	{
    14. 		printf("%s\n", strerror(errno));
    15. 		exit(-1);
    16. 	}
    17. 	fprintf(pf, "%s %d %f", s.arr, s.age, s.score);
    18. 	fclose(pf);
    19. 	pf == NULL;
    20. 	return 0;
    21. }

    读文件： 

    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. 	FILE* pf = fopen("test.txt", "r");
    11. 	if (pf == NULL)
    12. 	{
    13. 		perror("fopen fail");
    14. 		exit(-1);
    15. 	}
    16. 	fscanf(pf, "%s %d %f", s.arr, &(s.age), &(s.score));
    17. 	printf("%s %d %.2f\n", s.arr, s.age, s.score);
    18. 	fclose(pf);
    19. 	pf == NULL;
    20. 	return 0;
    21. }

    按照块读写文件fread、fwrite

    写文件：

    1. struct S
    2. {
    3. 	char arr[10];
    4. 	int age;
    5. 	float score;
    6. };
    7. int main()
    8. {
    9. 	struct S s = { "zhangsan",25,50.0f };
    10. 	FILE* pf = fopen("test.txt", "wb");
    11. 	if (pf == NULL)
    12. 	{
    13. 		perror("fopen fail");
    14. 		exit(-1);
    15. 	}
    16. 	fwrite(&s, sizeof(struct S), 1, pf);
    17. 	fclose(pf);
    18. 	pf == NULL;
    19. }

    读文件：

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

    注：C语言中有三个特殊的文件指针由系统默认打开，用户无需定义即可直接使用：

    1.stdin：标准输入流，默认为当前终端(键盘)，我们使用的scanf、getchar函数默认从此终端获得数据.

    2.stdout：标准输出流，默认为当前终端(屏幕)，我们使用的printf、puts函数默认输出信息到此终端.

    3.stderr：标准错误流，默认为当前终端(屏幕)，我们使用的perror函数默认输出信息到此终端.

     sprintf与sscanf:

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

    4.文件的随机读写 

    定位文件指针：fseek

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

     使文件指针回到文件的起始位置：rewind

    1. void WriteFile()
    2. {
    3. 	FILE* pf = fopen("test.txt", "w");
    4. 	if (pf == NULL)
    5. 	{
    6. 		perror("fopen fail");
    7. 		exit(-1);
    8. 	}
    9. 	char i = 0;
    10. 	for (i = 'a'; i <= 'f'; i++)
    11. 	{
    12. 		fputc(i, pf);
    13. 	}
    14. 	fclose(pf);
    15. }
    16. int main()
    17. {
    18. 	WriteFile();
    19. 	FILE* pf = fopen("test.txt", "r");
    20. 	if (pf == NULL)
    21. 	{
    22. 		perror("fopen fail");
    23. 		exit(-1);
    24. 	}
    25. 	fseek(pf, 2, SEEK_SET);
    26. 	int ch = fgetc(pf);
    27. 	printf("%c\n", ch);//c
    28. 	printf("%d\n", ftell(pf));//3
    29. 	fseek(pf, -1, SEEK_END);
    30. 	ch = fgetc(pf);
    31. 	printf("%c\n", ch);//f
    32. 	printf("%d\n", ftell(pf));//6
    33. 	rewind(pf);
    34. 	ch = fgetc(pf);
    35. 	printf("%c\n", ch);//a
    36. 	fclose(pf);
    37. 	pf = NULL;
    38. 	return 0;
    39. }

    5.文件读取结束的判定

    牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件是否结束，而是应用于文件读取结束的时候，判断是否是遇到文件尾结束.

    判断文件是否结束的方法：取决于函数返回值

    1.文本文件读取是否结束，判断返回值是否为EOF(fgetc)，或者NULL(fgets)

    例如：fgetc读取结束判断是否为EOF

               fgets读取结束判断返回值是否为NULL

    2.二进制文件读取是否结束，判断返回值是否小于实际要读的个数.

    例如：fread读取结束判断返回值是否小于实际要读的个数.

    1. int main()
    2. {
    3.     int c; 
    4.     FILE* pf = fopen("test.txt", "r");
    5.     if (pf == NULL)
    6.     {
    7.         perror("File opening failed");
    8.         return EXIT_FAILURE;
    9.     }
    10.     //fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
    11.     while ((c = fgetc(pf)) != EOF)  //标准C I/O读取文件循环
    12.     {
    13.         printf("%c ", c);
    14.     }
    15.     printf("\n");
    16.     //判断是什么原因结束的
    17.     if (ferror(pf))
    18.     {
    19.         puts("I/O error when reading");
    20.     }
    21.     else if (feof(pf))
    22.     {
    23.         puts("End of file reached successfully");
    24.     }
    25.     fclose(pf);
    26. }
    27.  

    1. enum 
    2. {
    3.     SIZE = 5
    4. };
    5. int main()
    6. {
    7.     double a[SIZE] = { 1.0,2.0,3.0,4.0,5.0 };
    8.     FILE* pf = fopen("test.bin", "wb"); //必须用二进制模式
    9.     fwrite(a, sizeof(a[0]), SIZE, pf);  //写double的数组
    10.     fclose(pf);
    11.     double b[SIZE] = { 0.0 };
    12.     pf = fopen("test.bin", "rb");
    13.     size_t ret_code = fread(b, sizeof(b[0]), SIZE, pf); //读double的数组
    14.     if (ret_code == SIZE)
    15.     {
    16.         puts("Array read successfully, contents: ");
    17.         for (int n = 0; n < SIZE; n++)
    18.         {
    19.             printf("%.2lf ", b[n]);
    20.         }
    21.         printf("\n");
    22.     }
    23.     else
    24.     {
    25.         if (feof(pf))
    26.         {
    27.             printf("Error reading test.bin: unexpected end of file\n");
    28.         }
    29.         else if (ferror(pf))
    30.         {
    31.             perror("Error reading test.bin");
    32.         }
    33.     }
    34.     fclose(pf);
    35. }

    6.文件缓冲区

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

    1. int main()
    2. {
    3.     FILE*pf = fopen("test.txt", "w");
    4.     fputs("abcdef", pf);//先将代码放在输出缓冲区
    5.     printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
    6.     Sleep(10000);
    7.     printf("刷新缓冲区\n");
    8.     fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
    9.     //注：fflush 在高版本的VS上不能使用了
    10.     printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
    11.     Sleep(10000);
    12.     fclose(pf);
    13.     //注：fclose在关闭文件的时候，也会刷新缓冲区
    14.     pf = NULL;
    15.     return 0;
    16. }

    结论：因为有缓冲区的存在，C语言在操作文件的时候，需要做刷新缓冲区或者在文件操作结束的时候关闭文件，如果不做会导致读写文件出现问题.

  • 相关阅读:
    高端之争：国产手机踏上释放「战略势能」的长期征途
    都知道0.1+0.2 = 0.30000000000000004，那要怎么让它等于0.3
    Spring boot使用websocket实现在线聊天
    [linux] 系统的基本使用
    不就是Java吗之数组的定义和使用
    简单聊聊 TCP 协议
    「低代码」跑通现代BI“最后一公里”的背后
    Python字符串介绍详解
    浏览器localStorage和sessionStorage详解、特点、区别、StorageEvent事件以及注意事项
    并发原理 — CPU原子性指令（一）
  • 原文地址：https://blog.csdn.net/qq_66767938/article/details/127709764