文件的操作

晚来听风雨

已于 2022-11-29 02:58:10 修改

阅读量192

点赞数 1

分类专栏： C语言文章标签： c语言

于 2022-07-24 18:58:43 首次发布

本文链接：https://blog.csdn.net/YZmu_yu/article/details/125962794

版权

C语言专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1、文件的打开和关闭

1.1文件指针

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

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

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

FILE* pf;//文件指针变量

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

1.2文件的打开和关闭

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

fopen 打开失败返回 NULL

//打开文件
FILE * fopen ( const char * filename, const char * mode );//(文件名/路径，方式)
//关闭文件
int fclose ( FILE * stream );

打开方式如下：

例子：

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

2、文件的顺序读写

fgetc

int fputc ( int character, FILE * stream );

fputc

int fgetc ( FILE * stream );

fgets

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

从文件流中获取字符串

从流中读取字符并将其作为 C 字符串存储到 str 中，直到读取（num-1）字符或达到换行符或文件末尾（以先发生者为准）。（num 位置上存放的是 ‘\0’ ；）

换行符使 fgets 停止读取，但它被函数视为有效字符，并包含在复制到 str 的字符串中。

终止空字符会自动追加到复制到 str 的字符之后。

fputs

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

将字符串写入文件流

将 str 所指向的 C 字符串写入流。

该函数开始从指定的地址（str）复制，直到到达终止空字符（'\0'）。此终止空字符不会复制到流中。

fscanf

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

从流中读取格式化数据

从流中读取数据，并根据参数格式将其存储到附加参数所指向的位置。

附加参数应指向已分配的对象，该对象由格式字符串中其相应的格式说明符指定。

fprintf

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

将格式化的数据写入流

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

在 format 参数之后，该函数需要至少与 format 指定的附加参数数相同。

流

//流
//FILE*
//
//printf
//scanf
//
//任何一个C程序，只要运行起来就会默认打开3个流：
//FILE* stdin - 标准输入流（键盘） 
//FILE* stdout - 标准输出流（屏幕）
//FILE* stderr - 标准错误流（屏幕）
//

fread

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

从流中读取数据块

从流中读取一个 count 元素数组，每个元素的大小为字节size，并将它们存储在 ptr 指定的内存块中。

流的位置指示器通过读取的字节总数来推进。

如果成功，读取的字节总数为（大小*计数）

fwrite

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

从 ptr 指向的当前位置写入一个 count 元素数组，每个元素的大小为字节 size。

流的位置指示器按写入的总字节数进行高级。

在内部，该函数将所指向的块解释为一个类型元素数组，并按顺序将它们写入，就好像为每个字节调用一样

sscanf

int sscanf ( const char * s, const char * format, ...);

从字符串中读取格式化数据

从 s 读取数据，并根据参数格式将它们存储到附加参数给出的位置，就像使用 scanf 一样，但从 s 而不是标准输入 stdin 读取。

附加参数应指向已分配的对象，该对象由格式字符串中其相应的格式说明符指定

sprintf

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

将格式化的数据读取到字符串

使用与在 printf 上使用格式时打印的相同文本编写字符串，但内容不是打印，而是作为 C 字符串存储在 str 所指向的缓冲区中。

缓冲区的大小应足够大，以包含整个生成的字符串

终止空字符会自动追加到内容之后。

例如：

struct S{
	char arr[64];
	int age;
	double score; 
};
int main(){
	struct S s={"zhangsan",18,50.1f};
	char buf[128]={0};
	sprintf(buf,"%s %d %f",s.arr ,s.age , s.score);
	printf("%s\n",buf);
	return 0;
}

3、文件的随机读写

fseek

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

int fseek ( FILE * stream, long int offset, int origin );
		  //  文件指针		   偏移量		  偏移的起始位置

例子：

#include <stdio.h>
int main ()
{
	  FILE * pFile;
	  pFile=fopen("test.txt","r");
	  if (pFile==NULL) perror ("Error opening file");
	  int ch;
	  
	  fseek(pFile,2,SEEK_SET);// SEEK_SET 开始的位置
	  ch=fgetc(pFile);
	  printf("%c\n",ch);
	  
	  fseek(pFile,2,SEEK_CUR);// SEEK_CUR 当前的位置
	  ch=fgetc(pFile);
	  printf("%c\n",ch);
	  
	  fseek(pFile,-1,SEEK_END);// SEEK_END 最后的位置
	  ch=fgetc(pFile);
	  printf("%c\n",ch);
	  
	  return 0;
}

ftell

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

long int ftell ( FILE * stream );

rewind

让文件指针的位置回到文件的起始位置

void rewind ( FILE * stream );

4、文件读取结束的判定

4.1 被错误使用的feof

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

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

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

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

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

正确的使用：
文本文件的例子：

#include <stdio.h>
#include <stdlib.h>
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 <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 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);
}

5、文件缓冲区

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

#include <stdio.h>
#include <windows.h>
//VS2013 WIN10环境测试
int main()
{
	FILE*pf = fopen("test.txt", "w");
	fputs("abcdef", pf);//先将代码放在输出缓冲区
    printf("睡眠10秒-已经写数据了，打开test.txt文件，发现文件没有内容\n");
    Sleep(10000);
    printf("刷新缓冲区\n");
    fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到文件（磁盘）
    //注：fflush 在高版本的VS上不能使用了
    printf("再睡眠10秒-此时，再次打开test.txt文件，文件有内容了\n");
    Sleep(10000);
    fclose(pf);
    //注：fclose在关闭文件的时候，也会刷新缓冲区
    pf = NULL;
    return 0;
}