C语言文件操作

kpl_20

已于 2024-04-26 19:19:20 修改

阅读量188

点赞数

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

于 2023-02-20 16:28:43 首次发布

本文链接：https://blog.csdn.net/kpl_20/article/details/129093716

版权

C 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、认识文件

文件存在的意义： 为了把数据做到持久化 --> 使用文件我们可以直接将数据存放到硬盘上

文件的分类：（从功能上分类）

文件分为程序文件和数据文件

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

注：本文主要介绍的是数据文件

①数据文件

数据文件：程序运行时需要从中读取数据的文件，或者输出内容的文件。

初学者，处理数据的输入输出都是以终端为对象
但是在有时候我们会把信息输出到磁盘上，当需要的时候再读取到内存中使用，而这里处理的就是磁盘上的文件。

②文件名

一个文件要有一个唯一的文件标识（文件名），以便用户使用。
文件名（三个部分）：文件路径 + 文件名主干 + 文件后缀
eg: c:\code\test.txt

二、文件的操作

1. 文件的打开和关闭

①文件指针

FILE：

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

文件类型声明的一种形式：

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

文件指针：

一般FILE结构的变量都是通过一个FILE的指针来维护。
FILE* pf; // 文件指针变量
通过文件指针变量pf我们能找到其指向的文件信息区，进而找到文件。

eg：图解
文件指针指向文件信息区

②文件的打开和关闭

对文件进行操作就得先打开文件，使用结束后需要关闭文件。在我们使用特定的函数打开文件时，会返回一个FILE*的指针变量，此时指针变量和文件建立起关系

ANSIC规定使用fopen函数打开文件，fclose函数关闭文件。

// 打开文件，使用fopen，成功返回一个FILE*类型的指针，失败NULL
函数声明：
	FILE* fopen(const char* filename, const char* mode);
参数：
	1. filename：文件名（+路径）
	2. mode：打开方式（下面讲）

//关闭文件，使用fclose，成功返回0，失败返回EOF
函数声明：
	int fclose(FILE* stream);
参数：
	stream：要关闭的文件的文件指针

文件打开方式：

eg：

#include <stdio.h>
int main()
{
	FILE* pf=fopen("test.txt", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//文件操作
	fputs("fopen example", pf);

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

代码中，test.txt这个是相对路径，文件在test.c这个路径中
D:\code\test.txt --> 绝对路径
. .\test.txt -->代表test.txt的上一级路径

2. 文件的顺序读写

举例：

fgets函数声明：char* fgets( char *string, int n, FILE *stream );
作用：从流中读取字符，并将它们作为 C 字符串存储到 str 中，直到读取（num-1）个字符或到达换行符或文件末尾

注：

换行符使 fgets 停止读取，但它被函数视为有效字符，并包含在复制到 str 的字符串中。
终止 null 字符会自动附加到复制到 str 的字符之后。
如果文件中的行确实包含换行符，并且 buffer 还有足够的空间来存储它（包括末尾的 ‘\0’），那么换行符也会被存储在 buffer 中。如果 buffer 的空间不足以存储换行符，那么换行符将不会被读取到 buffer 中，但 buffer 仍然会以 ‘\0’ 结尾。

#include <stdio.h>

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	//测试一行数据
	char buf[21] = { 0 };
	fgets(buf, 21, pf);
	printf("%s", buf);

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

在使用fgets的时候，参数n需要加一，才能满足向内存输入的字符数，因为’\0’会自动添加到buf中。

所有输入输出流解释
任何一个c语言程序运行时，默认打开3个流，类型都是FILE*
stdin ------- 标准输入 eg:键盘
stdout ------- 标准输出 eg:屏幕
stderr ------- 标准错误 eg:屏幕
所以可以直接使用标准输入输出函数

3. 文件的随机读写

①fseek

根据文件指针的位置和偏移量来定位文件指针
函数声明：int fseek (FILE* stream, long int offset, int origin);
参数介绍：
origin：填的是SEEK_SET、SEEK_CUR、SEEK_END，它们分别代表的意思是文件的起始位置，文件指针的当前位置和文件的结束位置。

eg：

#include <stdio.h>
int main()
{
	FILE* pf = fopen("test.txt", "wb");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	fputs("This is an apple.", pf);
	fseek(pf, 9, SEEK_SET);
	//表示pf指向的文件，指针在字符的第九个位置
	fputs(" sam", pf);
    //从n开始覆盖到第一个p覆盖完停止
    
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

②ftell

返回值是文件指针相对于起始位置的偏移量
函数声明：long int ftell(FILE* stream)

eg：

#include <stdio.h>
int main()
{
	FILE* pf = fopen("test.txt", "rb");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	fputs("This is a sample.", pf);
	fseek(pf, 0, SEEK_END);
	long int len = ftell(pf);

	printf("%ld\n", len);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

这个代码输出的结果就是文件中字符的数量，因为我把文件指针使用fseek函数放到了字符的最后一个位置。

③rewind

让文件指针的位置回到文件的起始位置
函数声明：void rewind(FILE* stream);

eg：

#include <stdio.h>

int main()
{
    FILE* pFile = fopen("test.txt", "w+");
    if (NULL == pFile)
    {
        perror("fopen");
        return 1;
    }
    char buffer[27];

    //向文件输出内容
    for (int n = 'A'; n <= 'Z'; n++)
        fputc(n, pFile);

    //让文件指针回到起始位置
    rewind(pFile);

    //从二进制文件里读取内容
    fread(buffer, 1, 26, pFile);

    //关闭文件
    fclose(pFile);
    pFile = NULL;
    buffer[26] = '\0';

    //向屏幕输出文件
    puts(buffer);
    return 0;
}

三、文本文件和二进制文件

根据数据的组织形式：数据文件又分为文本文件和二进制文件。
1.二进制文件：数据在内存以二进制的形式存储，不加以转换输出到外存。
2.文本文件：在外存上以ASCII码的形式存储，在存储前转换成ASCII字符的形式存储的文件。

注：数据存储

数据存储：字符一律按ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以用二进制形式存储。当数值较大时二进制形式输出到磁盘只需四个字节，而ASCII的形式可能要大得多。
eg:10000 二进制形式存储只需4个字节，而ASCII形式存储需要5个字节。

eg：

#include <stdio.h>
int main()
{
	int a = 10000;
	FILE* pf = fopen("test.txt", "wb");

	//二进制的形式写进文件
	fwrite(&a, 4, 1, pf);

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

转换二进制文件
在这里插入图片描述

四、文件读取结束的判定

文件读取是否结束，判断返回值

文本文件：两种方式
（1）fgetc函数判断返回值是否为EOF
（2）fgets函数判断返回值是否为NULL
二进制文件：
fread函数判断返回值是否要小于实际要读的个数。

在这我们要另外介绍两个函数feof、ferror，这两个函数用在当文件读取结束时，判断文件是读取失败结束，还是遇到文件尾结束。

eg1：文本文件

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int c = 0;
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen");
		return EXIT_FAILURE;
		//EXIT_FAILURE需要引用<stdlib.h>
	}

	//fgetc当读取失败的时候，或者遇到文件结束的时候，都会返回EOF
	while ((c = fgetc(pf)) != EOF)
	{
		putchar(c);
	}
	//判断结束原因
	if (ferror(pf))
	{
		puts("I/O error when reading");
	}
	else if (feof(pf))
	{
		puts("End of file reached successfully");
	}

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

eg2：二进制文件

#include <stdio.h>
#include <stdlib.h>
enum
{
	SIZE = 5
};

int main()
{
	double a[SIZE] = { 1.,2.,3.,4.,5. };
	FILE* pf = fopen("test.bin", "wb");
	if (NULL == pf)
	{
		perror("fopen");
		return EXIT_FAILURE;
	}
	//写文件
	fwrite(a, sizeof(a[0]), SIZE, pf);
	//关闭文件
	fclose(pf);
	pf = NULL;

	double b[SIZE] = { 0 };
	pf = fopen("test.bin", "rb");

	//使用
	size_t ret_count = fread(b, sizeof(*b), SIZE, pf);
	if (ret_count == SIZE)
	{
		puts("Array read successfully, contents:");
		for (int n = 0; n < SIZE; ++n)
		{
			printf("%f ", b[n]);
		}
		putchar('\n');
	}
	else //error handling
	{
		if (feof(pf))
		{
			puts("Error reading test.bin: unexpected end of file\n");
		}
		else if (ferror(pf))
		{
			puts("Error reading test.bin");
		}
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

五、文件缓冲区

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

缓冲文件系统

注：

因为有缓冲区的存在，c语言在操作文件的时候，需要刷新缓冲区或者文件操作结束的时候关闭文件。如果不做，可能会导致读写文件问题。

fflush：刷新缓冲区
函数声明：int fflush( FILE *stream );

六、对比一组scanf和printf形似的函数

printf/fprintf和scanf/fscanf是格式化输入输出函数

1. 标准输入输出流

stdin：标准输入流
stdout：标准输出流

①scanf – 格式化输入

函数声明：int scanf(const char *format, ...) 默认从标准输入 stdin 读取格式化输入

注：scanf()函数的调用格式

scanf(“<格式化字符串>”，参量地址)；

②printf – 格式化输出

函数声明： int printf(const char *format, ...) 发送格式化输出到流 stdout 中

注：printf()函数的调用格式为

printf(“<格式化字符串>”, <参量表>);
printf(“参数”)；

2. 所有输入输出流

在初期的学习中，我们学习了scanf、printf等函数，这些函数针对的都是标准输入输出流。
而有些函数是可以支持所有输入输出流（即标准输入输出流，也可以支持文件）

eg：fprintf、fscanf等就支持所有输入输出流

fscanf(stdin, "%d", &n); <=等价=> scanf("%d", &n);

①fprintf – 格式化输出函数

函数声明：int fprintf(FILE *stream, const char *format, ...) 发送格式化输出到流 stream 中

eg：

#include <stdio.h>

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

int main()
{
	struct S s = { "zhangsan",20,95.5 };
	FILE* pf = fopen("test.out", "w");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//写入文件
	fprintf(pf, "%s %d %f\n", s.name, s.age, s.score);
	//输出到屏幕
	fprintf(stdout, "%s %d %f\n", s.name, s.age, s.score);


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

②fscanf – 格式化输入函数

函数声明：int fscanf(FILE *stream, const char *format, ...) 从流 stream 读取格式化输入。

eg：

#include <stdio.h>

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

int main()
{
	struct S s = { 0 };
	FILE* pf = fopen("test.out", "r");
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}

	//读取文件到内存
	fscanf(pf, "%s %d %f", s.name, &(s.age), &(s.score));
	//将读取的内容，输出到屏幕
	fprintf(stdout, "%s %d %f\n", s.name, s.age, s.score);
	
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

这段代码使用fscanf函数把文件里的内容读取到内存中，然后又使用fprintf函数输出到屏幕中。（当然前提是有这个要读取的文件，不然会出现错误）

eg2：使用fscanf和fprintf模拟使用scanf和printf

#include <stdio.h>

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

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

	//向内存输入内容
	fscanf(stdin, "%s %d %f", s.name, &(s.age), &(s.score));
	//向屏幕输出内容
	fprintf(stdout, "%s %d %f\n", s.name, s.age, s.score);

	return 0;
}

3. sscanf和sprintf

使用sscanf和sprintf要包含头文件<stdlib.h>

①sscanf

函数声明：int sscanf ( const char * s, const char * format, ...);
从字符串中读取格式化输入

eg：

#include <stdio.h>

int main()
{
	char sentence[] = "Rudolph is 12 years old";
	char str[20];
	int i;

	sscanf(sentence, "%s %*s %d", str, &i); // 没有读取到的也会被省略
	printf("%s -> %d\n", str, i);

	return 0;
}
//output:Rudolph -> 12

注：

%s: 这将读取连续字符，直到遇到一个空格字符（空格字符可以是空白、换行和制表符）。
%*s: 把该字符串跳过。

②sprintf

函数声明：int sprintf(char *str, const char *format, ...)
将格式化的数据写入字符串

eg:

int main()
{
	char buffer[50];
	int n, a = 5, b = 3;
	n = sprintf(buffer, "%d plus %d is %d", a, b, a + b);
	printf("[%s] is a string %d chars long\n", buffer, n);
	return 0;
}
//output:[5 plus 3 is 8] is a string 13 chars long

小结

scanf - 从键盘上读取格式化的数据 - stdin
printf - 把数据输出（写到）屏幕上 - stdout

fscanf - 针对所有输入流的格式化的输入函数：stdin/文件
fprintf - 针对所有输出流的格式化的输出函数：stdout/文件

sscanf - 从一个字符串中，还原一个格式化的数据
sprintf - 把格式化的数据，存放在（转换成）一个字符串

kpl_20

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
C语言文件操作

文件：程序文件、数据文件。数据文件：文件名，文件的打开（fopen）和关闭（fclose），文件指针，文件的顺序读写（fgetc/fgets/fputc/fputs/fscanf/fprintf/fread/fwrite）和文件的随机读写（fseek/ftell/rewind），文本文件和二进制文件，文件读取结束判定，文件缓冲区 printf/fprintf/sprintf和scanf/fscanf/sscanf函数对比
复制链接

扫一扫