C语言——文件操作

int fgetc ( FILE * stream );

• 返回文件指针当前指向的字符，然后文件指针向后移动一位
• 如果文件指针位于文件末尾，那么就返回EOF，并为流设置 （feof） 的文件结束指示器
• 如果文件读取错误，同样返回EOF，但改为设置其错误指示器 （ferror）

示例：

若在.c文件的路径下有一名为data.txt的文件，这个文件有字符串“abcdef”

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "r");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}
	
	char ch;
	while ((ch = fgetc(fp)) != EOF)
		printf("%c", ch);
	printf("\n");

	fclose(fp);
	fp = NULL;

	return;
}

output:

abcdef

int fputc ( int character, FILE * stream );

• 将一个字符写入文件，然后文件指针向后移动一位
• 如果写入成功，那么返回这个字符的ASCII值
• 如果发生错误，则返回EOF

示例：

向同一文件逐个写入26个小写英文字符

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "w");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	char ch = 'a';
	char ret;
	for (int i = 0; i < 26; i++)
	{
		ret = fputc(ch + i, fp);
		printf("%c", ret);
	}

	fclose(fp);
	fp = NULL;

	return;
}

output:

abcdefghijklmnopqrstuvwxyz

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

• 从流（stream）中读取字符，并以字符串的形式存储到str中，直到读够（num - 1）个字符，或到达换行符，或读到文件尾

• 换行符‘\n’会使fgets停止读取，但换行符会被函数认为是有效字符，并存入str中

• 结束符‘\0’会成为第num个字符，添加到str末尾

• 如果读取成功，则返回str

• 如果在读取的过程中遇到文件尾，那么就设置 eof 指示器 （feof）

• 如果没有读到任何字符就遇到文件尾，那么就返回空指针，设置 eof 指示器 （feof），str的内容不会改变

• 如果读取错误，则设置错误指示器（ferror），同样返回空指针，但str的内容可能会改变

示例1：

从文件中读取26个小写字母

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "r");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	char ch[30] = {0};

	fgets(ch, 26 + 1, fp);

	puts(ch);

	fclose(fp);
	fp = NULL;

	return;
}

output:

abcdefghijklmnopqrstuvwxyz

示例2：

从文件读取以下内容：

123
456

output:

123
    

fgets：

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

gets：

char * gets ( char * str );

• fgets接受流参数（标准输入流，文件流都可以），而gets只接受标准输入流
• fets可指定读取的最大字符数
• fgets会将换行符读入到str再结束读取，而gets碰到换行符就会停止读取，不会读入换行符

例如：

#include<stdio.h>

int main()
{
	char str1[20] = { 0 };
	char str2[20] = { 0 };

	gets(str1);
	fgets(str2, 5 + 1, stdin);

	return 0;
}

同时在标准输入流读入“abcd\n”，利用调试，可以发现二者区别

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

• 将str中的字符串输出到流（stream）中，结束符‘\0’不会被写入
• 如果输出成功，则返回非负值
• 如果失败，则返回EOF，并设置错误指示器（ferror）

例如：

将字符串“abcdef”写入文件

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "w");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	char ch[] = "abcdef";

	int ret = fputs(ch, fp);
	printf("%d", ret);
    
    fclose(fp);
	fp = NULL;

	return;
}

output：

0

fputs:

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

puts:

int puts ( const char * str );

• fputs的输出对象可以被指定，而puts只能是标准输出流stdout
• puts输出会自带一个换行符‘\n’，而fputs不会

例如：

#include<stdio.h>

int main()
{
	char str[] = "abcdef";

	puts(str);
	printf("HELLO");

	printf("\n");

	fputs(str, stdout);
	printf("HELLO");

	printf("\n");

	return 0;
}

output

abcdef
HELLO
abcdefHELLO

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

• 以格式化的形式从流（stream）中读取数据

• 成功后，该函数返回成功填充的参数列表的项数。此计数可以与预期的项目数匹配，也可以由于匹配失败、读取错误或文件末尾的到达而减少（甚至为零）。

• 如果发生读取错误或在读取时到达文件末尾，则会设置正确的指示器（feof 或 ferror）。并且，如果在成功读取任何数据之前发生任一情况，则返回 EOF。

例如：

从文件中读取数字123和字符串“abcdef”

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "r");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	char str[10] = { 0 };
	int num = 0;

	fscanf(fp, "%d %s", &num, str);

	printf("%d\n%s\n", num,str);
    
    fclose(fp);
	fp = NULL;

	return;
}

output:

123
abcdef

scanf:

int scanf ( const char * format, ... );

sscanf:

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

fscanf:

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

• 三者都是以格式化的形式读取数据
• 三者在**遇到空格时会停止读取，且不会读取空格字符。**这是因为默认情况下，这些函数以空白字符（包括空格、制表符和换行符）作为输入字段的分隔符
• scanf只能从标注输入流（stdin）读取，sscanf只能从字符串中读取，fscanf可以从标准输入流或文件流读取

例如：

文件内容为: 123 abcdef

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "r");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	int num1 = 0;
	int num2 = 0;
	int num3 = 0;

	char str1[20] = "123 abcdef";
	char str2[10] = { 0 };
	char str3[10] = { 0 };

	scanf("%d", &num1);

	sscanf(str1, "%d%s", &num2, str2);

	fscanf(fp, "%d%s", &num3, str3);

	printf("num1 = %d, str1 = %s\n", num1, str1);
	printf("num2 = %d, str2 = %s\n", num2, str2);
	printf("num3 = %d, str3 = %s\n", num3, str3);

	fclose(fp);
	fp = NULL;

	return 0;
}

input:

123

output:

num1 = 123, str1 = 123 abcdef
num2 = 123, str2 = abcdef
num3 = 123, str3 = abcdef

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

• 以格式化的形式向流（stream）中输出数据

• 成功后，将返回写入的字符总数。

• 如果发生写入错误，则设置错误指示器（ferror）并返回负数。

例如：

将数字123和字符串“abcdef”写入文件

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "w");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	char str[10] = "abcdef";
	int num = 123;

	int ret = fprintf(fp, "%d%s", num, str);

	printf("ret = %d\n", ret);
    
    fclose(fp);
	fp = NULL;

	return;
}

output:

ret = 9

注：如果在%d%f中加入一个空格，那么返回值就会加一

printf:

int printf ( const char * format, ... );

sprintf:

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

fprintf:

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

• 三者都是以格式化的形式输出
• print用于将格式化的数据输出到标准输出流（屏幕）；sprintf用于将格式化的数据输出到字符串中；fprintf用于将格式化的数据输出到指定流。

例如：

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "w");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	int num1 = 10;
	int num2 = 10;
	int num3 = 0;

	char str1[10] = "abcdef";
	char str2[10] = { 0 };

	printf("num1 = %d\n", num1);

	sprintf(str2, "%s", str1);
	puts(str2);

	fprintf(fp, "%d %s", num1, str1);

	fclose(fp);
	fp = NULL;

	return 0;
}

outputs:

num1 = 10
abcdef

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

• 以二进制的形式从流中读取count个元素，每个元素的大小为size字节，并将它们存储在 ptr 指定的内存块中。

• 返回成功读取的元素总数。

• 如果此数字与 count 参数不同，则表示读取时发生读取错误或到达文件末尾。在这两种情况下，都会设置正确的指标，可以分别用 ferror 和 feof 进行检查。

• 如果size或count为零，则该函数返回零，并且流状态和 ptr 指向的内容保持不变。

例如：

读取文件中的字符串“1200”

int main()
{
	FILE* fp = fopen("data.txt", "rb");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	int str[10] = {0};

	int ret = fread(str, sizeof(int), 1, fp);
	for (int i = 0; i < 10; i++)
		printf("%d ", str[i]);

	printf("\nret = %d\n", ret);
    
    fclose(fp);
	fp = NULL;

	return;
}

output:

808464945 0 0 0 0 0 0 0 0 0
ret = 1

• 可能有小伙伴不理解为什么是这个结果，我们一起来分析：
• 我们知道，fread是以二进制的形式读取文件中的信息，而文件中的1200是文本信息，每个字符对应的ASCII码为49,50,48,48，转换为二进制码：0011 0001 0011 0010 0011 0000 0011 0000
• 再看看808464945的二进制形式：

• 可以发现，数据竟然是倒着读取的，这里就又涉及到了小端字节序存储这一概念，文件前面的数据是低地址，后面的数据是高地址，而低位数据存储在低地址，高位数据存储在高地址，因此最终读取到的数据就要将文本信息倒着读

注：

对小端字节序存储该不太了解的同学请看这里👉传送门

在C语言中，文件的数据存储方式取决于计算机的体系结构和操作系统。通常情况下，对于大多数计算机系统，文件的数据是按照字节顺序存储的，这意味着在内存中，文件前面的数据存储在较低的地址，后面的数据存储在较高的地址。

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

• 以二进制的形式将ptr存储的数据写入流中，一共写入count个元素，每个元素的大小为size字节。

• 返回成功写入的元素总数。

• 如果此数字与 count 参数不同，则写入错误阻止函数完成。在这种情况下，将为流设置错误指示器（ferror）。

• 如果size或count为零，则该函数返回零，错误指示器保持不变。

例如：

向文件中写入字符串“abcdef”

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "wb");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}

	char str[] = "abcdef";

	int ret = fwrite(str, sizeof(char), strlen(str), fp);
	printf("%d\n", ret);

	fclose(fp);
	fp = NULL;

	return 0;
}

output:

6

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

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

• offset为偏移量
• origin为起始位置，有三种取值：

SEEK_SET：文件头

SEEK_CUR：文件指针的当前位置

SEEK_END：文件尾

• 如果成功，则返回0，否则返回非零值
• 如果发生读写错误，那么就设置错误指示器（ferror）。

例如：

先向文件写入26个小写英文字母，再从文件头偏移3个单位，写入字符串“DEF”

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "r+");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}
	
	char a = 'a';
	char str[30] = { 0 };
	for (int i = 0; i < 26; i++)
		fputc(a + i, fp);

	fseek(fp, 3, SEEK_SET);

	fprintf(fp, "%s", "DEF");

	fseek(fp, 0, SEEK_SET);
	
	fscanf(fp, "%s", str);
	puts(str);
	
	fclose(fp);
	fp = NULL;

	return 0;
}

output:

abcDEFghijklmnopqrstuvwxyz

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

long int ftell ( FILE * stream );

例如：

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "w");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}
	
	char a = 'a';
	for (int i = 0; i < 26; i++)
		fputc(a + i, fp);

	printf("%d\n", ftell(fp));
	
	fclose(fp);
	fp = NULL;

	return 0;
}

output:

26

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

void rewind ( FILE * stream );

例如：

#include<stdio.h>

int main()
{
	FILE* fp = fopen("data.txt", "w+");
	if (NULL == fp)
	{
		perror("fopen");
		return 1;
	}
	
	char str[30] = { 0 };

	for (int i = 0; i < 26; i++)
		fputc('a' + i, fp);

	rewind(fp);

	for (int i = 0; i < 10; i++)
		fputc('A' + i, fp);

	rewind(fp);

	fscanf(fp, "%s", str);
	puts(str);
	
	fclose(fp);
	fp = NULL;

	return 0;
}

output:

ABCDEFGHIJklmnopqrstuvwxyz