一些简单的文件操作_简单文件操作-CSDN博客

本文深入介绍了C语言中文件的打开、关闭、读写操作，包括文本文件和二进制文件的处理，以及文件指针、文件流的概念。通过实例展示了fopen、fclose、fputc、fgetc、fputs、fgets、fprintf、fscanf、fwrite和fread等函数的使用，还讲解了文件的随机读写、文件结束判定等高级操作。

文章目录

**文件名**
**文件类型**
**文件指针**
**文件的打开和关闭**
**文件的顺序读写**
**文件的随机读写**
**文件结束判定**

文件名

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

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

例如： c:\code\test.txt

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

文件类型

根据数据的组织形式，数据文件被称为文本文件或者二进制文件。

文本文件用记事本打开是可以直接看明白的，而二进制文件用记事本打开是一串乱码

数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。

如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

一个数据在内存中是怎么存储的呢？

字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储。

如有整数10000，如果以ASCII码的形式输出到磁盘，则磁盘中占用5个字节（每个字符一个字节），而二进制形式输出，则在磁盘上只占4个字节（VS2019测试）。

图示是以十六进制的形式表示

测试代码：

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

将文件夹下的test.txt拖到vs2019中，在解决方案资源管理器处，右击tset.txt，再按照图示点击，就可以看到10000的二进制存储了

文件指针

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

每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名字，文件状态及

文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统声明的，取名FILE.

例如,VS2008编译环境提供的 stdio.h 头文件中有以下的文件类型申明：

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

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

每当打开一个文件的时候，系统会根据文件的情况自动创建一个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 );

打开方式如下：

文件使用方式	含义	如果指定文件不存在
“r”（只读）	为了输入数据，打开一个已经存在的文本文件	出错
“w”（只写）	为了输出数据，打开一个文本文件	建立一个新的文件
“a”（追加）	向文本文件尾添加数据	建立一个新的文件
“rb”（只读）	为了输入数据，打开一个二进制文件	出错
“wb”（只写）	为了输出数据，打开一个二进制文件	建立一个新的文件
“ab”（追加）	向一个二进制文件尾添加数据	出错
“r+”（读写）	为了读和写，打开一个文本文件	出错
“w+”（读写）	为了读和写，建议一个新的文件	建立一个新的文件
“a+”（读写）	打开一个文件，在文件尾进行读写	建立一个新的文件
“rb+”（读写）	为了读和写打开一个二进制文件	出错
“wb+”（读写）	为了读和写，新建一个新的二进制文件	建立一个新的文件
“ab+”（读写）	打开一个二进制文件，在文件尾进行读和写	建立一个新的文件

“w”、“wb”、“w+”、"wb+"都会将文件中已经存在的内容覆盖成新内容

例如：

int main()
{
	FILE* p = fopen("test.txt", "w");
	if (p == NULL)
	{
		perror("fopen");
		return -1;
	}
	fclose(p);
	p = NULL;
	return 0;
}

如果此时test.txt这个文件已经存在并已经有内容，则按照上述代码，不对文件进行输入操作，文件内的内容会被覆盖（清空）

此时我们往test.txt放入内容

程序编译后：

里面的内容就被覆盖了

上面所述是文件text.txt与该程序存在于同一目录的情况

如果文件与程序不存在于同一文件时，

这是test.txt所在的位置

这是该程序所在的位置

程序报错如下：

这种情况，我们应该把test.txt的绝对位置也放在fopen里

在加地址的时候我们要注意：\不能单独出现，不然会被当成其他的转义字符，要写两个\，才表示\

test.txt里的内容：

结果就是读取了test.txt中的第一个字符h：

实例代码：

/* fopen fclose example */
#include <stdio.h>
int main ()
{
  FILE * pFile;
  pFile = fopen ("myfile.txt","w");
  if (pFile!=NULL)
 {
    fputs ("fopen example",pFile);//fputs就是一个文本输出函数
    fclose (pFile);
 }
  return 0; }

文件的顺序读写

功能	函数名	适用于
字符输入函数	fgetc	所有输入流
字符输出函数	fputc	所有输出流
文本行输入函数	fgets	所有输入流
文本行输出函数	fputs	所有输出流
格式化输入函数	fscanf	所有输入流
格式化输出函数	fprintf	所有输出流
二进制输入	fread	文件
二进制输出	fwrite	文件

fputc

向所有类型的输出流（文件、标准输入输出、硬盘、光盘等等）传递字符数据，当连续传递时，会自动往后传递，而不是覆盖

打开文件时，就是打开了一个文件流

C程序只要运行起来，就默认打开了3个流：stdin、stdout、stderr

stdin是标准输入流-键盘

stdout是标准输出流-屏幕

stderr是标准错误流-屏幕

三者都是通过FILE*来维护的（指向的）

例如：

int main()
{
	FILE* p = fopen("test.txt", "w");
	if (p == NULL)
	{
		perror("fopen");
		return -1;
	}
	else
	{
		fputc('a', p);
		fputc('b', p);
		fputc('c', p);
		fputc('d', p);
		
	}
	fclose(p);
	p = NULL;
	return 0;
}

编译前test.txt：

编译后：

fputc(‘a’, p)也可以写成fputc(‘a’, stdout)中，即打印在屏幕上

如：

int main()
{
	FILE* p = fopen("test.txt", "w");
	if (p == NULL)
	{	
		perror("fopen");
		return -1;
	}
	else
	{
		fputc('a', stdout);
		fputc('b', stdout);
		fputc('c', stdout);
		fputc('d', stdout);
		
	}
	fclose(p);
	p = NULL;
	return 0;
}

fopen(“test.txt”, “w”)中的w是指写入字符到test.txt中

fgetc

从任意类型的输入流中读取字符

返回字符的ASCII码值

注意在使用时，fopen(“test.txt”, “r”)的r是指从test.txt中读取一个字符，不同于fputc中的"w"

例：

int main()
{
	FILE* p = fopen("test.txt", "r");
	if (p == NULL)
	{
		perror("fopen");
		return -1;
	}
	else
	{

	int ch =	fgetc(p);
	printf("%c\n", ch);
		ch = fgetc(p);
		printf("%c\n", ch);
		ch = fgetc(p);
		printf("%c\n", ch);
		ch = fgetc(p);
		printf("%c\n", ch);

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

从test.txt中读取字符，test.txt存放字符如下：

结果如下：

同样，也可以将int ch = fgetc§写成int ch = fgetc(stdin)，从键盘上读取字符

我们改动一下代码再编译：

fputs

向所有类型的输出流（文件、标准输入输出）传递文本行(字符串)，连续传递时效果与fputc相同

为什么fputs及之前的fgetc、fputc的返回类型都是int呢？

1.它们返回的都是字符的ASCII码值，ASCII码值是整形数据

2.当读取到文件末尾时，返回的是EOF，EOF的值是-1，而char是存放不了-1这种32位的整形数据的

例：

int main()
{
	FILE* p = fopen("test.txt", "w");
	if (p == NULL)
	{
		perror("fopen");
		return -1;
	}
	else
	{
		fputs("hello", p);
		fputs("hehe", p);
    }
	fclose(p);
	p = NULL;
	return 0;
}

结果如下：

如果想实现换行，在hello后加\n就可以实现了

fgets

从所有类型的输入输出流中读取一个文本行(字符串)

第一个参数string是接收读取字符串的指针（数组）地址；第二个参数n表示要读取的长度；第三个参数即为流的指针，从这里读取一个字符串

例如：

int main()
{
	char arr[20];
	FILE* p = fopen("test.txt", "r");
	if (p == NULL)
	{
		perror("fopen");
		return -1;
	}
	else
	{
		/*fputs("hello", p);
		fputs("hehe", p);*/
		fgets(arr, 5, p);
		printf("%s\n", arr);
	}
	fclose(p);
	p = NULL;
	return 0;
}

fgets从test.txt中读取5个字符，但实际上只会读取4个，第五个是\0

test.txt中的内容为：

读取结果：

我们可以把5修改成6，结果就是hello：

当然，也可以写成20，全部读取其中的内容，并打印arr中的所有内容：

拷贝文件内容至另一个文件：

先用fgets从源文件中获取内容，输入至一个临时数组中，再通过fputs将临时数组的内容输出至目标文件中

int main()
{
	FILE* pread = fopen("test1.txt", "r");//从text1.txt中向程序中输入一定字符
	if (pread == NULL)
	{
		perror("fopen");
		return -1;
	}

	FILE*pwrite = fopen("test2.txt", "w");//向text2.txt中输出一定字符
	if (pwrite == NULL)
	{
		fclose(pread);
		pread = NULL;
		perror("fopen");
		return -1;
	}
	int ch = 0;//ch接收从text1.txt中获取的字符
	while ((ch = fgetc(pread)) != EOF)//当读取到文件末尾时停止拷贝
	{
		fputc(ch, pwrite);//将ch接收的字符放入text2.txt中
	}
	//关闭文件
	fclose(pread);
	pread = NULL;
	fclose(pwrite);
	pwrite = NULL;
	return 0;
}

拷贝前test1.txt中的内容：

拷贝前test2.txt中的内容：

拷贝后test2.txt中的内容：

此时就完成了拷贝

fprintf

格式化输出（不止包括字符、字符串，还有其他类型的数据，如结构体）

例：

struct s {
	char name[20];
	int age;
	float score;
};
int main()
{
	struct s s1 = {"zhangsan", 20, 80.0f };
	FILE* p = fopen("test.txt", "w");
	if (p == NULL)
	{
		perror("fopen");
		return -1;
	}
	else {
		fprintf(p, "%s %d %f", s1.name, s1.age, s1.score);
	}

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

输出前text.txt中的内容：

输出后test.txt中的内容：

fscanf

格式化输入

我们把上面已经输出至test.txt中的内容，再输入至s1中

例：

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

结果如下：

fwrite

fwrite是将数据以二进制的形式进行输出

原型：size_t fwrite( const void * buffer,size_t size, size_t count, FILE * stream);

const void * buffer 是数据源的地址

size_t size 是写入内容的大小

size_t count 是写入内容的个数或者最多写入内容的个数，具体取决于buffer指向的数据多少，也就是写入count个size的内存

FILE * stream 是输出的目的地(流)

例：

struct S {
	char a[10];
	int b;
	float c;
};
int main()
{
	struct S s = { "abcde", 10, 2.4f };
	//打开文件
	FILE* p = fopen("test.txt", "w");
	if (p == NULL)
	{
		perror("fopen");
		return -1;
	}
	//输出数据
	fwrite(&s, sizeof(s), 1, p);//将结构体s中的数据以二进制的形式存放至文件中
	//关闭文件
	fclose(p);
	return 0;
}

test.txt中的内容：

我们只能识别abcde是数组a里的内容，因为这种方式就是以字符的形式存放的，而其他的数据我们仅凭肉眼很难识别

那怎么能翻译这些东西呢？

接下来就该fread发力了

fread

参数与fwrite相同，但数据源和目的地的位置相反

如上面fwrite是从s中获取数据，写入test.txt中

而想把test.txt中的数据存入s中，参数位置不变，和fwrite相同

我们把test.txt中的数据再次返回至s中：

struct S {
	char a[10];
	int b;
	float c;
};
int main()
{
	struct S s = { 0 };
	//打开文件
	FILE* p = fopen("test.txt", "r");
	if (p == NULL)
	{
		perror("fopen");
		return -1;
	}
	//输入数据
	fread(&s, sizeof(s), 1, p);//将将文件中的二进制数据经过转化存放至s中
	printf("%s %d %f", s.a, s.b, s.c);
	//关闭文件
	fclose(p);
	return 0;
}

结果：

由此，我们得知，fwrite与fread应该成对使用，不然那些二进制数据也没人看得懂

对比一组函数：

scanf/fscanf/sscanf

printf/fprintf/sprintf

scanf、printf针对标准输入输出流，也就是从键盘输入，向屏幕输出

fscanf、fprintf针对所有类型的流进行输入输出，即可以从键盘输入，向屏幕输出，又可以从文本输入，向文本输出

sscanf是将一个字符串数据提取为结构化数据(不是结构体)，sprintf是将一个结构化数据转化为字符串

sprintf的原型：

sprintf的例子：

struct s {
	char name[20];
	int age;
	float score;
};

int main()
{
	struct s s1 = { "zhangsan", 20, 80.5f };
	char arr[100];
	sprintf(arr, "%s%d%f", s1.name, s1.age, s1.score);
	printf("%s", arr);
	return 0;
}

结果：

sscanf的原型：

sscanf的例子：

struct s {
	char name[20];
	int age;
	float score;
};

int main()
{
	struct s s1 = { 0 };
	char arr[100] = "zhangsan 20 80.5";
	sscanf(arr, "%s%d%f", s1.name, &(s1.age), &(s1.score));
	printf("%s %d %f", s1.name, s1.age, s1.score);
	return 0;
}

结果：

注意：不能把arr里的内容写成"zhangsan2080.5"这种连在一起的形式，否则sscanf会将这整个字符串存入s1.name中

我们可以试下连在一起时会是什么结果：

可以看到zhangsan2080.5都放入了s1.name中，s1.age, s1.score中放的都是0

sprintf、sscanf的详细使用大家可以进一步去找资料了解，这里只是简单地讲一下这三种函数的区别

文件的随机读写

fseek

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

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

参数stream流

参数offset是指相对于origin的偏移量

参数origin有三种选择：

SEEK_CUR是指文件指针当前所指位置

SEEK_END是指文件的末尾

SEEK_SET是指文件的开头

例子：

	/* fseek example */
#include <stdio.h>
int main ()
{
  FILE * pFile;
  pFile = fopen ( "example.txt" , "wb" );
  fputs ( "This is an apple." , pFile );//向文件中写入This is an apple.
  fseek ( pFile , 9 , SEEK_SET );//使pFile指向从文件开始偏移的第九个字节处，也就是n
  fputs ( " sam" , pFile );//从n开始向后修改“n a"为" sam"
  fclose ( pFile );
  return 0; }

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);   //使pFile指向文件末尾
    size=ftell (pFile);//size就等于文件的大小
    fclose (pFile);
    printf ("Size of myfile.txt: %ld bytes.\n",size);
 }
  return 0; }

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';
  puts (buffer);
  return 0;
  }

文件结束判定

被错误使用的 feof

feof 函数在第一次尝试读取文件末尾的读取操作后返回一个非零值。如果当前位置不是文件结尾，则返回 0。

牢记：在文件读取过程中，不能用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);
}

补充：ferror，如果读取文件失败，返回非零值，反之，返回0

二进制文件的例子：

以fwrite、fread为例：

#include <stdio.h>
enum { SIZE = 5 };
int main(void) {
    double a[SIZE] = {1.0,2.0,3.0,4.0,5.0};
    double b = 0.0;
    size_t ret_code = 0;
    FILE *fp = fopen("test.bin", "wb"); // 必须用二进制模式
    fwrite(a, sizeof(*a), SIZE, fp); // 写 double 的数组
    fclose(fp);
    fp = fopen("test.bin","rb");
    // 读 double 的数组
    while((ret_code = fread(&b, sizeof(double), 1, fp))>=1)
   {
        printf("%lf\n",b);
   }
    if (feof(fp))
        printf("End of file reached successfully");//读取文件成功而结束
    else if (ferror(fp)) {
        perror("Error reading test.bin");//由于读取文件失败而结束
   }
    fclose(fp);
    fp = NULL; }