C-文件操作

文件

1.程序文件

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

2.数据文件

文件的内容不一定是程序，而是程序运行时读写的数据，

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

而我们主要讨论的就是数据文件。

数据文件被称为文本文件或者二进制文件。

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

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

3.文件名

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

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

例：c:\code\test.txt

文件的打开和关闭

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结构的变量，并填充其中的信息， 使用者不必关心细节。

一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。

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

通过文件指针变量能够找到与它关联的文件。

在文件内部，存在位置指针，指向所要访问的位置

2.文件的打开和关闭

文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。（闭环操作）

文件以EOF结束

fopen()

FILE * fopen ( const char * filename, const char * mode );

filename:文件名(文件路径+文件名主干+文件后缀),文件路径缺省情况，默认为当前工作路径

mode:模式

文件打开失败后，返回NULL

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

注：

• 打开文件后要判断，是否为空
• 闭环操作，必须关闭文件
• "w"或"wb",打开文件时会清空原文件，再进行写操作

fclose()

int fclose ( FILE * stream );

例：

#include<stdio.h>
#include<assert.h>
#define _CRT_SECURE_NO_WARNINGS
int main(int argc,char*argv[])
{
	//1.打开文件
	FILE* fp = fopen("test1.txt", "w");
	//1.1判空
	if (fp == NULL)
	{
		printf("文件打开失败！\n");
		return 0;
	}
	//1.1.2判空
	assert(fp != NULL);
	//assert(fp);
	printf("文件打开成功！\n");


	fclose(fp);
}

3.文件的顺序读写

fprintf()&fscanf()

适用于所有输入输出流

fprintf()

格式化输出函数，数据输出至文件（重定向）,"w"

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

写文件时，数据被放入缓冲区，并没有立即放入文件中，一般当程序结束时或缓冲区满时，会将数据放入文件！

空格分隔数据，文件中的数据把本质为一个个字符，每一个字符为一个字节！

使用

int main(int argc, char* argv[])
{
	int arr[] = {12,46,58,78,546,5,241,6542,132,213};
	int n = sizeof(arr) / sizeof(arr[0]);
	//1.打开文件
	FILE* fp = fopen("test1.txt", "w");
	//1.1判空
	if (fp == NULL)
	{
		printf("文件打开失败！\n");
		return 0;
	}
	for (int i = 0; i < n; ++i)
	{
		fprintf(fp, "%d ", arr[i]);
	}
	printf("fprintf成功！\n");
	fclose(fp);
}

fscanf()

格式化输入函数，从文件中读取数据（重定向），"r"

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

使用：

int main(int argc, char* argv[])
{
	int arr[10] = { 0 };
	
	//1.打开文件
	FILE* fp = fopen("test1.txt", "r");
	//1.1判空
	if (fp == NULL)
	{
		printf("文件打开失败！\n");
		return 0;
	}
	for (int i = 0; i < 10; ++i)
	{
		fscanf(fp, "%d ", &arr[i]);
	}
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("fscanf成功！\n");
	fclose(fp);
}

fgetc()&fputc()

适用于所有输入输出流

fputc()

字符输出函数，

int fputc ( int character, FILE * stream );

例：

fputc(ch,fp);

fgetc()

字符输入函数

int fgetc ( FILE * stream );

例：

ch=fgetc(fp);

使用：文件复制

int main(int argc, char* argv[])
{
	FILE* fp1 = fopen("test1.txt", "r");
	assert(fp1!=NULL);
	FILE* fp2 = fopen("test2.txt", "w");
	assert(fp2!=NULL);

	char ch=fgetc(fp1);
	while (ch != EOF)
	{
		fputc(ch,fp2);
		ch=fgetc(fp1);
	}
	fclose(fp1);
	fclose(fp2);
}

fputs()&fgets()

适用于所有输入输出流

fputs()

文本行输入函数

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

str -- 这是一个数组，包含了要写入的以空字符终止的字符序列。

stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符串的流。

返回值

该函数返回一个非负值，如果发生错误则返回 EOF。

fgets()

文本行输出函数

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

str -- 这是指向一个字符数组的指针，该数组存储了要读取的字符串。

n -- 这是要读取的最大字符数（包括最后的空字符）。通常是使用以 str 传递的数组长度。

stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要从中读取字符的流。

返回值：

如果成功，该函数返回相同的 str 参数。如果到达文件末尾或者没有读取到任何字符，str 的内容保持不变，并返回一个空指针。

如果发生错误，返回一个空指针。

int main(int argc, char* argv[])
{
	FILE* fp1 = fopen("fileOperation.c", "r");
	assert(fp1 != NULL);
	FILE* fp2 = fopen("test2.txt", "w");
	assert(fp2 != NULL);

	char buff[128] = {0};
	char* res = fgets(buff, 128, fp1);
	while (res != EOF)
	{
		fputs(buff, fp2);
		res = fgets(buff, 128, fp1);
	}
	fclose(fp1);
	fclose(fp2);
}

fread()&fwrite()

适用于文件

一个字节一个字节的读取，写入，文件的格式都不会该改变，内容不变。原封不动

fread()

二进制输出流，"rb"

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)

ptr -- 这是指向带有最小尺寸 size*nmemb 字节的内存块的指针。

size -- 这是要读取的每个元素的大小，以字节为单位。

nmemb -- 这是元素的个数，每个元素的大小为 size 字节。

stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输入流

返回值

成功读取的元素总数会以 size_t 对象返回，size_t 对象是一个整型数据类型。

如果总数与 nmemb 参数不同，则可能发生了一个错误或者到达了文件末尾。

fwrite()

二进制输入流, "wb"

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

ptr -- 这是指向要被写入的元素数组的指针。

size -- 这是要被写入的每个元素的大小，以字节为单位。

nmemb -- 这是元素的个数，每个元素的大小为 size 字节。

stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输出流。

返回值

如果成功，该函数返回一个 size_t 对象，表示元素的总数，该对象是一个整型数据类型。

如果该数字与 nmemb 参数不同，则会显示一个错误。

使用：复制文件

复制任何文件

int main(int argc, char* argv[])
{
	FILE* fp1 = fopen("what_if.png", "rb");
	assert(fp1 != NULL);
	FILE* fp2 = fopen("test3.png", "wb");
	assert(fp2 != NULL);

	char buff[128] = { 0 };
	size_t num = fread(buff, sizeof(char), 128, fp1);
	while (num != 0)
	{
		fwrite(buff, sizeof(char), 128, fp2);
		num = fread(buff, sizeof(char), 128, fp1);
	}
	
	fclose(fp1);
	fclose(fp2);
}

4.文件的随机读写

在文件中数据以字符形式存储。

文件数据的位置 0123456789

文件中的数据     12 34 56 7

1.fseek()

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

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

stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。

offset -- 这是相对 origin 的偏移量，以字节为单位。 正数，向左；负数，向右；

origin -- 这是表示开始添加偏移 offset 的位置。它一般指定为下列常量之一：

常量 描述

SEEK_SET 文件的开头

SEEK_CUR 文件指针的当前位置

SEEK_END 文件的末尾

返回值

如果成功，则该函数返回零，否则返回非零值。

void main()
{
	FILE *fp = fopen("test1.txt", "r");
	assert(fp != NULL);

	//随机读取
	int pos;
	int value;
	while(1)
	{
		printf("input pos:>");
		scanf("%d", &pos);

		fseek(fp, pos*3, SEEK_SET);

		fscanf(fp, "%d", &value);
		printf("value = %d\n", value);
	}

	fclose(fp);
}

如果要这种访问效果呢？

0 1 2     3

1 2 32 500

同类型数据，都占四个字节，使用二进制文件存储，具有一致性

文件中每一个符号代表1个字节

通过fseek（）调整文件指针位置，每次位置所指数据为整型占4字节，所以*4

通过fread()函数读取二进制文件中的数据，存在buff数组（自定义缓冲区）

但存储数据为字符型，转为整型表示方式，通过内存函数memcpy（）每个字节都拷贝到整型变量read中

打印出来就是，十进制形式

//数据存入二进制文件中
int main(int argc, char* argv[])
{
	int arr[] = { 12,46,58,78,546,5,241,6542,132,213 };
	int n = sizeof(arr) / sizeof(arr[0]);
	//1.打开文件
	FILE* fp = fopen("test1.txt", "wb");
	//1.1判空
	if (fp == NULL)
	{
		printf("文件打开失败！\n");
		return 0;
	}
	fwrite(arr, sizeof(int), n, fp);
	printf("fwrite成功！\n");
	fclose(fp);
}
//随机访问数值
int main()
{
	FILE* fp = fopen("test1.txt", "rb");
	int pos;
	int read=0;
	char buff[4] = { 0 };
	while (1)
	{
		printf("pos:>");
		scanf("%d", &pos);
		fseek(fp, pos*4, SEEK_SET);
		fread(buff, sizeof(char), 4, fp);
		memcpy(&read, buff, sizeof(int));
		printf("%d\n", read);
		
	}
	fclose(fp);
}

2.ftell()

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

long int ftell ( FILE * stream );

3.rewind()

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

void rewind ( FILE * stream );

使用：

void main()
{
	FILE *fp = fopen("test1.txt", "r");
	assert(fp != NULL);
	//01234567
	//12 23 34 45 56 67 78 89 90 100
	int pos = ftell(fp);
	printf("pos = %d\n", pos);

	int tmp;
	fscanf(fp,"%d", &tmp);
	pos = ftell(fp);
	printf("pos = %d\n", pos);

	fscanf(fp,"%d", &tmp);
	pos = ftell(fp);
	printf("pos = %d\n", pos);

	rewind(fp);
	pos = ftell(fp);
	printf("pos = %d\n", pos);

	fclose(fp);
}

5.文件读取结束的判定

ferror()

文件读取失败结束

feof()

文件读到文件尾

应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

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

        例如： fgetc 判断是否为 EOF .

                        fgets 判断返回值是否为 NULL .

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

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

使用：文本文件

int main(void)
{
	int c; 
	FILE* fp = fopen("Test1.txt", "r");
	if (!fp) 
	{
		perror("File opening failed");
		return EXIT_FAILURE;
	}
	
	//fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while ((c = fgetc(fp)) != EOF) // 标准C I/O读取文件循环
	//while(!feof(fp))
	{
		c = fgetc(fp);
		putchar(c);
	}
	printf("\n");
	
	//判断是什么原因结束的
	if (ferror(fp))
		puts("I/O error when reading");
	else if (feof(fp))
		puts("End of file reached successfully");
	fclose(fp);
}

二进制文件

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

可以对以上例子作出修改

最难不过坚持！