C语言全面细致讲解文件操作

目录

• 什么是文件
• 程序文件
• 数据文件
• 文件名
• 文件指针
• 文件的打开和关闭
• 文件的顺序读写
• 字符输入输出函数
• 字符串输入输出函数(fgets,fputs)
• 格式化输入输出函数(fscanf,fprintf)
• 二进制输入输出函数(fread,fwrite)
• 文件的随机读写
• fseek
• ftell
• 文件读取结束的判定

什么是文件

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

程序文件

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

后缀为.exe）。

数据文件

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

在这里我们主要说的是讨论的是数据文件。在以前所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。

文件名

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

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

例如： c:\code\test.txt

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

文件指针

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

不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。

每当打开一个文件的时候，系统会根据文件的情况自动创建一个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* pf = fopen("test.txt", "w");//打开文件，以写的方式打开，文件名叫"test,txt"
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//文件操作
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

在这里我们可以看看文件的使用方式：

由图我们可以知道文件的使用围绕读和写进行。

文件的顺序读写

字符输入输出函数

fputc字符输出函数

int fputc ( int character, FILE * stream );//库函数中的定义

将字符写进数据流中，字符被写入流的内部位置指示器指示的位置，然后自动前进一个。通俗点来说就是文件在被操作过程的时候其实是有一个位置信息的，在操作过程中时刻发生变化

#include 
int main()
{
	FILE* pf = fopen("test.txt", "w");//打开文件名，以写的方式打开
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	写文件
	fputc('a', pf);//往文件里输出
	fputc('b', pf);
	fputc('c', pf);
//文件在被操作过程的时候其实是有一个位置信息的，在操作过程中时刻发生变化
	关闭文件
		fclose(pf);
	pf = NULL;
	return 0;
}

这时候我们打开我们这个代码所在位置，可以看到里面有’test.txt"这个文件，打开这个文件可以看到我们写入的字符

在我们找’test.txt"这个文件的时候我们要注意我们是否打开了文件扩展名，如果你没有打开的话，可能就找不到’test.txt"文件了。具体操作如下：

fgetc（字符输入函数）

int fgetc ( FILE * stream );

从流中获取字符返回指定流的内部文件位置指示符当前指向的字符。 然后，内部文件位置指示器前进到下一个字符。

如果调用时流位于文件末尾，该函数将返回EOF并设置流的文件结尾指示符（feof）。

如果发生读取错误，函数将返回EOF并设置流的错误指示器（ferror）。

#include 
int main()
{
	FILE* pf = fopen("test.txt", "r");//打开文件名，以读的方式打开
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	char ch=fgetc(pf);//这是我们不知道读到了什么可以打出来看看
	printf("%c\n", ch);
	 ch = fgetc(pf);
	printf("%c\n", ch);
	ch = fgetc(pf);
	printf("%c\n", ch);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

这时我们打开刚刚生成的文件’test.txt",往里面写入xyz三个字符，读的时候打印出来看看读到了什么。

所以我们可以知道，当我们读取的时候，读完一个字符，文件的位置信息就会发生变化，每次读取完，它会自动往下一个字符位置走。

扩展：

我们还可以利用上面两个函数将一个文件内容拷贝到另一个文件中。

例如：

#include 
int main()
{
	FILE* pfRead = fopen("test1.txt", "r");
	if (pfRead == NULL)
	{
		perror("open file for reading");
		return 1;
	}
	FILE* pfWrite = fopen("test2.txt", "w");
	if (pfWrite == NULL)
	{
		perror("open file for reading");
		fclose(pfRead);
		pfRead = NULL;
		return 1;
	}
	char ch = 0;
	while((ch = fgetc(pfRead)) != EOF)
	{
		fputc(ch, pfWrite);
	}
	//关闭文件
	fclose(pfRead);
	pfRead = NULL;
	fclose(pfWrite);
	pfWrite = NULL;
	return 0;
}

这个时候我们先去创建一个"test.txt"文件，然后我们将这段代码放进去，然后再点击编译看看效果。

点击编译后我们看看效果：

这样子就成功将"test1.txt"中的内容拷贝到"test1.txt"里了。

字符串输入输出函数(fgets,fputs)

字符串输出函数fputs:

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

将str指向的C字符串写入流。函数从指定的地址（str）开始复制，直到到达终止的空字符（’\0’）。此终止空字符不会复制到流中。并且它不会自动在末尾追加换行符，如果我们需要换行处理，可以自己在末尾加上换行符" \n"。

举个例子：

#include 
int main()
{
	FILE* pf = fopen("test.txt", "w");//打开文件名，以写的方式打开
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写数据
	fputs("hello world\n",pf);\\不会自动换行，所以自己可以加上换行符
	fputs("haha\n", pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

将字符串"hello world"和"haha"写入文件名为"test.txt"文件中。这时让我们打开这个文件：

字符串输入函数fgets

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

从流中读取字符，并将其作为C字符串存储到str中，直到读取（num-1）个字符，或者到达换行符或文件结尾，以先发生的为准。num为str的大小。

举个例子：

#include 
int main()
{
	char input [20]= { 0 };//将读到的数据存放进来
	FILE* pf = fopen("test.txt", "r");//打开文件名，以写的方式打开
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//读数据
	fgets(input, 20, pf);
	printf("%s", input);
	fgets(input, 20, pf);
	printf("%s", input);
	fclose(pf);
	pf = NULL;
	return 0;
}

将我们上面pf指向的"test.txt"文件中的字符串"hello world"和"haha"读出来，并放在input中然后将其打印出来。

格式化输入输出函数(fscanf,fprintf)

格式化输出函数fprintf

int fprintf ( FILE * stream, const char * format, … );

将格式指向的C字符串写入流。如果format包含格式说明符（子序列以%开头），则format后面的附加参数将被格式化并插入结果字符串中，以替换其各自的说明符。

举个例子：

#include 
struct stu
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct stu s = { "zhangsan",20,66.5f };
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen");//如果打开失败，打印失败原因
		return 1;
	}
	fprintf(pf, " %s %d %f", s.name, s.age, s.score);
	fclose(pf);
	pf = NULL;
	return 0;
}

将结构变量s里面的s.name, s.age ,s.score,分别以字符串，整数，浮点型形式写入pf指向的文件"test.txt"中。

格式化输入函数fscanf

int fscanf ( FILE * stream, const char * format, … );

从流中读取数据，并根据参数格式将其存储到附加参数所指向的位置。附加参数应指向已分配的对象，该对象的类型由格式字符串中相应的格式说明符指定。

举个例子：

#include 
struct stu
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct stu s = { 0 };
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	fscanf(pf, "%s %d %f", s.name,&( s.age), &(s.score));
	printf("%s %d %f", s.name, s.age, s.score);
	fclose(pf);
	pf = NULL;
	return 0;
}

从pf指向的"test.txt"中将数据分别以字符串，整数，浮点型形式读到结构体变量s中name,age,score中去。

二进制输入输出函数(fread,fwrite)

二进制输出函数fwrite

size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );

将数据块写入流中，将ptr指向的内存块写入流中的当前位置，每个元素的大小为字节（size)。count为一共写入数据个数。

举个例子：

#include 
struct stu
{
	char name[20];
	int age;
	float score;
};
#include 
int main()
{
	struct stu s = { "zhangsan",20,66.5f };
	FILE* pf = fopen("test.txt", "wb");
	if (pf == NULL)
	{
		perror("fopen file for writting");
		return 1;
	}
	fwrite(&s,sizeof(struct stu),1,pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

对结构体变量取地址，将结构体变量s里面的内容写入pf指向的"test.txt"中，结构体变量大小为sizeof(struct stu)，且写入的变量只有一个。

这个时候我们打开文件，我们会发现是我们看不懂的字符，这是为什么呢？

字符串不管是以文本形式还是二进制形式放进去，内存中数据都一样，但是整形和浮点型它们以ASCII和二进制形式放进去，内存中数据是不一样的。

二进制输入函数fread

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

从流中读取数据块,从流中读取计数元素数组，每个元素的大小为大小字节，并将它们存储在ptr指定的内存块中。如果成功，则读取的字节总数为(size*count)。

举个例子：因为刚刚写入的数据我们是看不懂的，但是编译器懂，我们现在将它读出来看看效果。

#include 
struct stu
{
	char name[20];
	int age;
	float score;
};
#include 
int main()
{
	struct stu s = {0 };
	FILE* pf = fopen("test.txt", "rb");
	if (pf == NULL)
	{
		perror("fopen file for writting");
		return 1;
	}
	fread(&s, sizeof(struct stu), 1,pf);
	printf("%s %d %f", s.name, s.age, s.score);
	fclose(pf);
	pf = NULL;
	return 0;
}

这时候我们看到读出来了，对结构体变量取地址，将pf指向的"test.txt"里面的数据读到结构体变量s里去，结构体大小为sizeof(struct stu)，读出来了一个结构体变量s。

文件的随机读写

fseek

根据文件指针的位置和偏移量来定位文件指针。

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

long int offset是偏移量， int origin是偏移起始位置。

在这里我们介绍三个偏移位置：

SEEK_SET：从起始位置开始偏移

SEEK_END：从末尾开始偏移

SEEK_CUR:从当前位置开始偏移

举个例子：

#include 
int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("open");
		return 1;
	}
	fputs("ABCDEF", pf);
	fseek(pf,2, SEEK_SET);//从起始位置开始偏移
	/*fseek(pf,-2, SEEK_CUR);*///从当前位置开始偏移
	/*fseek(pf,-3, SEEK_END);*///从末尾开始偏移
	fputc('G', pf);
	fclose(pf);
	pf = NULL;
	return 0;
}

ftell

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

long int ftell ( FILE * stream );

举个例子：

#include 
int main()
{
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("open");
		return 1;
	}
	fputs("ABCDEF", pf);
	fseek(pf,2, SEEK_SET);//这时候指针指向了从起始位置开始偏移，偏移量为2的位置上的C
	int ret = ftell(pf);//因为此时指针指向C，它相当于起始位置偏移量为2
	printf("ret = %d\n", ret);
	fclose(pf);
	pf = NULL;
	return 0;
}

文件读取结束的判定

feof这个函数要牢记：在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。

而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

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

例如：

fgetc 判断是否为 EOF .

fgets 判断返回值是否为 NULL .

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

例如：

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

举个文本文件例子：

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

二进制文件例子：

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

到此这篇关于C语言全面细致讲解文件操作的文章就介绍到这了,更多相关C语言文件操作内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！