c语言中的文件操作

于 2024-06-06 09:15:54 发布
阅读量1k 收藏 17
点赞数 37
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84421190/article/details/139422209
版权

1. 为什么使用文件


我们前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、删除数
据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，等下次运行通讯
录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。
我们在想既然是通讯录就应该把信息记录下来，只有我们自己选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，我们一般数据持久化的方法有，把数据存放在磁盘文件、存放到数据库等方式。
使用文件我们可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。


 
2. 什么是文件


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


2.1 程序文件


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


2.2 数据文件


文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，
或者输出内容的文件。
本章讨论的是数据文件。
在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。

2.3 文件名


一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含3部分：文件路径+文件名主干+文件后缀
例如： c:\code\test.txt
为了方便起见，文件标识常被称为文件名。

3. 文件的打开和关闭


3.1 文件指针


缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。
每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息（如文件的名
字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。该结构体类型是有系统
声明的，取名FILE.
例如，VS2013编译环境提供的 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指向某个文件的文件信息区（是一个结构体变
量）。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件。
比如：

也就是说，使用一个指针变量就可以找到文件中的值

3.2 文件的打开和关闭


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

文件打开成功的话返回有效的指针，失败返回NULL；

一般形式为

#include<stdio.h>
int main()
{
	//1.打开文件
	FILE*p=fopen("date.txt", "w");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//写文件...


	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}

4.文件的顺序读写

4.1文件打开时的方式

测试：

#include<stdio.h>
int main()
{
	//1.打开文件
	FILE*p=fopen("date.txt", "w");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//...
	return 0;
}

没有开始执行之前，没有date.txt文件

执行之后就产生了这个文件。

如果原来有这个文件，使用"w"的形式打开，执行之后文件中的东西会消失

如果用"r"的方式来看，一开始有这个文件，可以正常使用。

如果没有，就报错。

如何找到文件夹：

4.1.1打开不仅仅可以在当前文件下还可以在桌面

只要把桌面上的地址写出来就好了。

4.1.2还可以放在上一个路径。（当前文件夹的前面）

.   表示当前路径

..  表示上一个路径

表示为在当前路径（文件）下的上一个路径（文件）

这表示上上一个路径（文件）下。

4.2文件读写使用的函数

fputc

参数1：字符

参数2：文件指针

意思：要写的字符放在文件指针中

#include<stdio.h>
int main()
{
	//1.打开文件
	FILE*p=fopen("date.txt", "w");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//写文件...
	fputc('a', p);
	fputc('b', p);
	fputc('c', p);
	fputc('d', p);
	fputc('e', p);
	fputc('f', p);
	fputc('g', p);
	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}

fgetc

读取成功会返回读到文件指针中的字符的ASCII码值

读取失败会返回EOF（-1）

EOF--end of file

文件的结束标志

#include<stdio.h>
int main()
{
	//1.打开文件
	FILE*p=fopen("date.txt", "r");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//读文件...
	int ch = fgetc(p);
	printf("%c", ch);
	ch = fgetc(p);
	printf("%c", ch);
	ch = fgetc(p);
	printf("%c", ch);
	ch = fgetc(p);
	printf("%c", ch);
	ch = fgetc(p);
	printf("%c", ch);
	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}

原本文件中存的是abcdefg，所以用五次fgetc可以读取abcde。

如何读完文件中存的所有值呢，我们知道在末尾的时候会遇到EOF

#include<stdio.h>
int main()
{
	//1.打开文件
	FILE* p = fopen("date.txt", "r");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//读文件...
	int ch = 0;
	while ((ch = fgetc(p)) != EOF)
	{
		printf("%c", ch);
	}
	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}

fputs

参数1：字符指针

参数2：文件指针

return：成功返回一个非负的数，错误返回EOF同时设置一个错误的标志，可以用ferror来检查

写字符串到文件指针中

fgets

参数1：一个字符串

参数2：一个整形变量

参数3：文件指针

return：成功的话返回的是str的起始地址，失败返回一个空指针（NULL）

从文件指针中最多放入几个到字符串里面（包括\n以及\0）

如果遇到换行，会把\n放在str里面.后面都会补一个\0

#include<stdio.h>
int main()
{
	//1.打开文件
	FILE* p = fopen("date.txt", "r");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//读文件...
	char arr[20] = "xxxxxxxxxxxx";
	fgets(arr,5, p);
	printf("%s", arr);
	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}

fprintf(前面四个关于字符，这个可以是其他)

fprintf和printf的参数是差不多的，但是fprintf前面多一个文件指针，所以相当于把printf的内容放到文件指针中

struct S
{
	char name[20];
	int age;
	float score;
};
int main()
{
	struct S s = { "lisi",18,88.8f };
	//1.打开文件
	FILE* p = fopen("date.txt", "w");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//写文件...
	fprintf(p,"%s %d %f", s.name, s.age, s.score);
	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}

fscanf

fscanf也只是多了一个文件指针

struct S
	{
		char name[20];
		int age;
		float score;
	};
	int main()
	{
		struct S s = { 0 };
		//1.打开文件
		FILE* p = fopen("date.txt", "r");
		//再判断是否打开成功
		if (p == NULL)
		{
			//使用之前学的perror，可以判断出错误信息是什么
			perror("fopen");
			return 1;
		}
		//读文件...
		fscanf(p, "%s %d %f", s.name, &(s.age), &(s.score));
		printf("%s %d %f", s.name, s.age, s.score);
		//关闭文件
		fclose(p);
		p = NULL;
		return 0;
	}

读的是上面fprintf输入到文件的内容

读的时候s.name是字符串，代表的是首字符的地址，而s.age，s.score分别是整数和字符串，所以要用&

延申：sprintf

这个不是文件指针的内容。

将格式化的数据写到字符串中（str）

可以理解为，将格式化的数据转换成字符串

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

延申：sscanf

这个和ssprintf逻辑相反，是从s中提取数据到后面的参数

可以理解为，将字符串转换成格式化的数据

struct S
	{
		char name[20];
		int age;
		float score;
	};
int main()
{
	char arr[100] = { 0 };
	struct S s = { "wangwu",20,66.6f };
	struct S tmp = { 0 };
	sprintf(arr, "%s %d %f", s.name, s.age, s.score);
	//从字符串arr中提取数据到tmp中
	sscanf(arr, "%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
	printf("%s %d %f", tmp.name, tmp.age, tmp.score);
	return 0;
}

fwrite

写字符块到文件指针中

在str指向的空间中有count个大小为size的字符块写到文件指针中

struct S
{
	char name[20];
	int age;
	float score;
};
	int main()
	{
		struct S s = { "xiao ming",20,66.6f };
        //写二进制的信息到文件中
		//1.打开文件
		FILE* p = fopen("date.txt", "wb");
		//再判断是否打开成功
		if (p == NULL)
		{
			//使用之前学的perror，可以判断出错误信息是什么
			perror("fopen");
			return 1;
		}
		//写文件...
		fwrite(&s, sizeof(struct S), 1, p);
		//关闭文件
		fclose(p);
		p = NULL;
		return 0;
	}

fread

从文件指针中读取count个大小为size个字节的数据，存放在ptr指向的空间中

int main()
{
	struct S s = {0};
	//读取文件中二进制的信息
	//1.打开文件
	FILE* p = fopen("date.txt", "rb");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//读文件...
	fread(&s, sizeof(struct S), 1, p);
	printf("%s %d %f", s.name, s.age, s.score);
	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}


5.文件的随机读写

fseek

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

参数1：文件指针

参数2：距离起始位置的偏移量

参数3：起始位置,只有下列3个

int main()
{	
	//1.打开文件
	FILE* p = fopen("date.txt", "r");
	//再判断是否打开成功
	if (p == NULL)
	{
		//使用之前学的perror，可以判断出错误信息是什么
		perror("fopen");
		return 1;
	}
	//读文件...  文件中存的是abcdef
	//如果我们想读e
	fseek(p, 2, SEEK_END);
	int ch = 0;
	ch = fgetc(p);
	printf("%c", ch);
	//关闭文件
	fclose(p);
	p = NULL;
	return 0;
}

 ftell

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

rewind

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

7. 文件读取结束的判定


7.1 被错误使用的 feof

文件结束的情况有两种

1：遇到文件结尾

2：发生错误

feof并不是判断文件结束的标志，而是在已经知道文件结束的情况下，判断文件读取结束的原因是否为遇到了文件结束

1. 文本文件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
例如：
fgetc 判断是否为 EOF .
fgets 判断返回值是否为 NULL .
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。
例如：
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，有则返回非0.

二进制文件的例子

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

8. 文件缓冲区


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

竞了么个竞
关注
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值