C语言--文件操作

前言

在我们写完一个程序之后，我们输入的一些数据只是暂时的，当我们退出程序重新进入该程序，之前输入的数据就没有了，为了能有效的保存这些数据，就引进了文件来进行存储；

C语言进行文件操作的主要目的是为了数据的永久保存和数据的读取。下面是一些C语言进行文件操作的好处：

1. 永久保存：C语言的程序在运行时，数据是存储在内存中的，一旦程序关闭，内存中的数据就会丢失。通过文件操作，可以将数据保存在磁盘上，以实现永久保存。
2. 数据交流：文件操作可以实现不同程序之间的数据交流。一个程序可以将数据写入文件，另一个程序可以从文件中读取数据，从而实现数据的共享和传递。
3. 数据备份：文件操作可以用于数据备份。将数据保存在文件中，即使发生意外情况导致程序数据丢失，可以通过读取备份文件来恢复数据。
4. 数据分析：文件操作为数据分析提供了便利。将大量数据写入文件后，可以使用其他工具或程序对文件进行处理和分析，以获取有价值的信息。
5. 数据持久化：通过文件操作，可以将程序中的临时数据持久化存储，以便下一次程序运行时可以读取之前的数据，提高程序的稳定性和效率。

文件

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

程序文件：包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe）。
数据文件：文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。

在本章以数据文件讨论为主；在之前的操作中，都是以终端为对象，就是用scanf输入，printf打印到屏幕一样，只要我们退出程序一切都要重新来过；那么我们就可以通过磁盘中的文件进行存储，当要使用时再将它取出；

文件名

对于磁盘来说，有众多个文件，当我们需要寻找某个文件的时候，就需要通过文件名来寻找；在我们的桌面上，寻找某个文件的存储位置时，可以右击点击属性中得以寻找；
一般来说，文件名包含3部分：文件路径+文件名主干+文件后缀；

如：c:\code\test.txt
test就是文件名的主干，.txt就是文件后缀，前面的部分就是文件路径

文件的路径，一般分为两种，一种是相对路径，另一种是绝对路径；它们的主要区别在于参考的起点不同。

绝对路径:是从计算机文件系统的根目录开始描述文件或目录的位置。在不同的操作系统中，根目录的表示方法不同，例如在Windows系统中是以盘符（如C:\）开头，而在Unix/Linux系统中是以斜线（/）开头。绝对路径包括了从根目录到目标文件或目录的全部路径信息，可以确切地定位文件或目录的位置。
相对路径:是相对于当前工作目录或者指定的起点目录来描述文件或目录的位置。相对路径不包括根目录的信息，而是根据当前位置或指定的起点目录来确定相对位置。常见的相对路径表示方式有"./“（表示当前目录）、”…/"（表示上级目录）等。

这是我程序中的当前工作目录，当我在程序中使用

FILE* ppf=fopen(“…\data.txt”,“w”);

这里如果不懂是什么意思把它看作做当前目录的上一级目录创建一个新的文件；这就是相对路径；

D:\VSC\fnc\test7_16\data.txt
这种就是绝对路径，从你的磁盘的盘符开始作为起点；

文件的打开和关闭

文件指针

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

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是由系统声明的，取名FILE.
一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。

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

文件的打开和关闭

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

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

打开方式：

前三个比较经常使用

在写代码中，一般这样使用：

#include 
int main ()
{
  //打开文件
  FILE* pFile = fopen ("myfile.txt","w");
  if(pFile==NULL)//判断是否为空,打开失败则为空
  {
  	perror("fopen");
		return 1;
  }
  //文件操作
    fputs ("fopen example",pFile);
    //关闭文件
    fclose (pFile);
    pFile=NULL;
    //关闭后，指针需要置空
 }
  return 0;

文件的顺序读写

流：是指信息从一处向另一处流动的过程，是对一种有序连续且具有方向的数据的抽象描述；

里面说的所有，表明流向不是单一的，
在我们C语言程序中，只要运行起来就有三种标准流；

1. 标准输入流（stdin）：它用于从键盘接收用户输入的数据。在C语言中，可以使用标准库函数scanf()来读取标准输入流中的数据。
2. 标准输出流（stdout）：它用于向屏幕打印输出结果。在C语言中，可以使用标准库函数printf()来向标准输出流中输出数据。
3. 标准错误流（stderr）：它用于向屏幕打印程序的错误信息。在C语言中，可以使用标准库函数fprintf()来向标准错误流中输出错误信息

像文件形式的：

一般都以程序为主；

fgetc、fputc

int fgetc ( FILE * stream );
int fputc ( int character, FILE * stream );

#include
int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写入文件
    fputc('a', pf);
    fputc('b', pf);
	fputc('c', pf);
	
	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

像我们这样操作就会把一个一个字符写入文件中；

pf会随着写入字符而向右移动；而当我们退出程序重新编译时，那么会将之前文件中的内容清除重新编写；

#include
int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
    int ch=fgetc(pf);
    //该函数返回值为整型
    printf("%c",ch);
	ch=fgetc(pf);
    printf("%c",ch);
	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

输出：ef

也能从标准输入流输入

#include
int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
    
	//读文件
	int ch = fgetc(stdin);
	printf("%c\n", ch);
	ch = fgetc(stdin);
	printf("%c\n", ch);
	ch = fgetc(stdin);
	printf("%c\n", ch);
	ch = fgetc(stdin);
	printf("%c\n", ch);

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

这里写入123456，由于fgetc只输入一个字符，所以对于后面的数字就暂存在标准输入流中，每次只取出一个字符，总共取4次；

fgets、fputs

char * fgets ( char * str, int num, FILE * stream );
int fputs ( const char * str, FILE * stream );

#include
int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//写文件 - 写一行
	fputs("hello marco", pf);
	fputs("hello xixihaha\n", pf);

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

注意这里是不会换行的

#include
int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//读文件 - 读一行
	char arr[10] = { 0 };
	fgets(arr, 10, pf);
	printf("%s", arr);
	fgets(arr, 10, pf);
	printf("%s", arr);

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

会将文件中的字符串复制给字符数组中，长短由第二个参数决定，pf随着字符串复制而移动；

fprintf、fsanf

int fprintf ( FILE * stream, const char * format, … );
将格式化数据写入流
int fscanf ( FILE * stream, const char * format, … );
从流中读取格式化数据

#include
struct S
{
	int a;
	float s;
};


int main()
{
	FILE* pf = fopen("data.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	struct S s = { 100, 3.14f };
	fprintf(pf, "%d %f", s.a, s.s);

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

#include
struct S
{
	int a;
	float s;
};

int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	struct S s = {0};
	fscanf(pf, "%d %f", &(s.a), &(s.s));

	fprintf(stdout, "%d %f", s.a, s.s);

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

fread、fwrite

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
从流中读取数据块
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
将数据块写入到流中
第一个参数是指针，指向要写出或者读入的元素数组，第二个参数是单个元素的大小，第三个参数是元素的个数；第四个参数为文件；

#include
struct S
{
	int a;
	float s;
	char str[10];
};

int main()
{
	struct S s = { 99, 6.18f, "bit" };

	FILE* pf = fopen("data.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	fwrite(&s, sizeof(struct S), 1, pf);

	fclose(pf);
	pf = NULL;

	return 0;
}

我们看到这里是一堆看不懂的东西，这是由于二进制存储的；
我们要读取时，只需要用相同的二进制读取方式即可，不用管里面内容的形式；在第三个参数中，可以根据数组中的大小进行改变数量；

#include
struct S
{
	int a;
	float s;
	char str[10];
};

int main()
{
	struct S s = { 0 };

	FILE* pf = fopen("data.txt", "rb");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	fread(&s, sizeof(struct S), 1, pf);
	printf("%d %f %s\n", s.a, s.s, s.str);

	fclose(pf);
	pf = NULL;

	return 0;
}

文件的随机读写

fseek

int fseek ( FILE * stream, long int offset, int origin );
根据文件指针的位置和偏移量来定位文件指针。

第一个参数：指向标识流的 FILE 对象的指针
第二个参数：二进制文件：要从源偏移的字节数。
文本文件：零或 ftell 返回的值。
第三个参数：用作偏移参考的位置。

#include
int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	//定位文件指针到f
	int ch = fgetc(pf);
	printf("%c\n", ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c


	fseek(pf, -3, SEEK_CUR);
	//pf已经走都c位置之后，SEEK_CUR表示当前指针位置，-3就是向前移动三步；
	ch = fgetc(pf);
	printf("%c\n", ch);

	fclose(pf);
	pf = NULL;
	return 0;
}

ftell

long int ftell ( FILE * stream );
获取流中的当前位置,相对于初始位置；

#include


int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	//定位文件指针到f
	int ch = fgetc(pf);
	printf("%c\n", ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c


	int pos = ftell(pf);
	printf("%d\n", pos);
    //3

	fclose(pf);
	pf = NULL;
	return 0;
}

rewind

void rewind ( FILE * stream );
将流的位置设置为开头

#include
int main()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	//定位文件指针到f
	int ch = fgetc(pf);
	printf("%c\n", ch);//a

	ch = fgetc(pf);
	printf("%c\n", ch);//b

	ch = fgetc(pf);
	printf("%c\n", ch);//c

	rewind(pf);

	ch = fgetc(pf);
	printf("%c\n", ch);//a

	fclose(pf);
	pf = NULL;
	return 0;
}

文本文件和二进制文件

二进制文件和文本文件是计算机中常见的两种文件类型，它们在存储方式、可读性和使用场景上存在一些区别。

1. 存储方式：

• 文本文件：文本文件由字符组成，使用字符编码（如ASCII、UTF-8）将可打印的字符映射为二进制数据存储。文本文件可以直接使用文本编辑器打开和编辑。
• 二进制文件：二进制文件以字节为单位存储数据，可以包含任意二进制数据，如图片、音频、视频等。二进制文件不直接以可读的形式呈现，需要特定的程序或工具来解析和处理。

2. 可读性：

• 文本文件：由于文本文件使用字符编码进行存储，其中的内容可以被普通的文本编辑器读取和编辑。文本文件内容通常以可读的形式展示，比如ASCII码对应的字符。
• 二进制文件：二进制文件的内容不以可读的形式展示，其中包含的是表示特定格式和结构的二进制数据。如果直接用文本编辑器打开二进制文件，会看到一些乱码或不可识别的字符。

3. 使用场景：

• 文本文件：文本文件通常用于存储和处理纯文本数据，如代码文件、配置文件、日志文件等。由于其可读性和易于处理的特点，文本文件在文本处理、数据分析等领域广泛应用。
• 二进制文件：二进制文件适用于存储和处理非文本数据，如图像、音频、视频等多媒体数据。这些文件需要特定的程序或工具进行解析和处理，如图片编辑器、音频播放器等。

像整数10000在不同文件中的存储：

对于ASCII形式的文本文件需要占5个字节，而二进制形式存储只需要4个字节；

文件读取结束的判定

feof

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

文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
二进制文件的读取结束判断，判断返回值是否小于实际要读的个数

对于文本文件来说，当字符或者字符串走到标识符时，才算结束；而途中也有可能读取失败而返回标识符；所有要判断两种情况；而feof就是其中走到末尾文件结束的时候就返回一个不为0的值；

#include 
#include 
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);
}

文件缓冲区

文件缓冲区（File Buffer）是操作系统中用于存储文件数据的一块内存区域。在读取或写入文件时，操作系统通常会使用缓冲区来暂时存储文件的数据，以提高读写的效率。

当需要从文件中读取数据时，操作系统会将一定大小的数据块从文件读取到文件缓冲区中，然后应用程序可以从缓冲区中读取数据。类似地，当需要写入数据到文件时，应用程序将数据写入文件缓冲区中，而不是直接写入文件。操作系统会负责将缓冲区中的数据定期地刷新到文件中。

使用文件缓冲区的好处是减少了频繁的磁盘访问操作，因为磁盘读写通常比内存读写慢得多。通过将数据缓存到内存中，可以减少对磁盘的读写次数，从而提高文件的读写效率。

另外，文件缓冲区还可以提供一些额外的功能，比如在读取大文件时，可以使用缓冲区分批读取数据，以避免一次性加载整个文件到内存中造成内存压力过大。