⌛前言⌛

在之前的学习过程中，我们所编写的程序在执行过程中所产生的数据及结果都只是临时存放在内存区域，一旦程序运行结束，该程序所涉及的内存空间全部返回给操作系统。这时候如果我们想要去查看这些数据和结果，显然是做不到的！

那有没有什么方法能够解决这个问题呢？也就是说可以将程序运行过程所产生的过程数据和结果数据都保存起来，即便程序结束，我们也可以找到这些内容，甚至是在之后所写的其他程序中也能继续使用这些内容。

答案当然是-- - 有，这也就是我们这篇文章所要讨论的东西–文件。

---

一、什么是文件

1、站在程序设计角度，文件有两种：程序文件、数据文件

程序文件：

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

数据文件: 文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。文件名

2、文件名

一个文件要有一个唯一的文件标识，以便用户识别和引用。 文件名包含3部分：文件路径+文件名主干+文件后缀

例如：c:\code\test.txt

文件路径：c : \code 文件名主干：test 文件后缀：.txt

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

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

数据在内存中以二进制的形式存储，如果不加转换的输出到外存，就是二进制文件。 如果要求在外存上以ASCII码的形式存储，则需要在存储前转换。以ASCII字符的形式存储的文件就是文本文件。

4、文件存储

一个数据在内存中存储时，字符一律以ASCII形式存储，数值型数据既可以用ASCII形式存储，也可以使用二进制形式存储

10000（十进制）在内存中的存储图解示例：

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

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

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

---

二、文件缓冲区

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

将以下代码放到linux下跑一下，就可以清楚的感知到缓冲区的作用。

#include <stdio.h>
int main()
{
	while(1)
		{
			sleep(1);//在linux下表示停一秒
			printf("haha");
		}
		return 0;
}

---

三、文件指针

缓冲文件系统中, 关键的概念是“文件类型指针”, 简称“文件指针”。每个被使用的文件都在内存中开辟一个相应的文件信息区,用来存放文件的有关信息(如文件的名字、文件状态及文件当前位置等)。这些信息是保存在一个结构体变量中的。 该结构体类型是由系统声明的，取名为FILE。

例如: VS2013编译环境提供的stdio.h头文作中有以下的文件类型声明:

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

（注意：以上代码了解即可，有兴趣可自行研究） 不同的C编译器的FILE类型包含的内容不完全相同，但是大同小异。 每当打开一个文件的时候，系统会根据文件的情况自动创建一个FILE结构的变量，并填充其中的信息，使用者不必关心细节。 一般都是通过一个FILE的指针来维护这个FILE结构的变量，这样使用起来更加方便。 下面我们可以创建─个FILE* 的指针变量:

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

定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区（是一个结构体变量)。通过该文件信息区中的信息就能够访问该文件。也就是说，通过文件指针变量能够找到与它关联的文件

比如：

---

✨四、文件操作

⛲1.文件的打开和关闭

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

在编写程序的时候，在打开文件的同时，都会返回一个FILE* 的指针变量指向该文件，也相当于建立了

指针和文件的关系。

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

①fopen（打开）

FILE * fopen ( const char * filename, const char * mode );//文件名 ， 打开方式
int fclose ( FILE * stream );

函数原型：FILE* fopen(const char* filename, const char* mode); 函数功能：Open a file.（打开文件） 返回类型：Each of these functions returns a pointer to the open file.A null pointer value indicates an error.（如果打开成功，返回指向文件信息区的指针，如果返回失败，返回空指针NULL） 函数参数1：filename（文件名，实际上包括3部分内容，而不仅仅是文件名主干。如果文件路径未写，则默认本路径） 函数参数2：Type of access permitted（文件打开方式）

文件打开方式如下表：

注意：‘w’打开的时候如果有同名文件，该文件中的内容会被销毁

#include<stdio.h>
#include <errno.h>
#include <string.h>

int main()
{
	//打开文件test.txt
	FILE* pf = fopen("test.txt", "r");	//相对路径
	//.. 表示上一级路径
	//.  表示当前路径
	//fopen("../../test.txt", "r")

	//绝对路径的写法
	//fopen("D:\\桌面\\test-2\\test-2", "r"); //两个//是为了转义字符
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	//打开成功
	//读文件

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

---

②fclose（关闭）

int fclose(FILE* stream);

函数原型：int fclose(FILE* stream); 函数功能：Closes a stream(fclose) or closes all open streams(_fcloseall).（关闭文件） 返回类型：fclose returns 0 if the stream is successfully closed._fcloseall returns the total number of streams closed.Both functions return EOF to indicate an error（关闭文件成功返回0，关闭文件失败返回EOF（值为 - 1）来报错） 函数参数：Pointer to FILE structure（文件指针）

举例： 1）在项目工程所在文件路径下新建一个测试文件

2）测试代码

#include<stdio.h>
int main()
{
	//打开文件
	FILE* pf1 = fopen("test1.txt", "r");
	if (pf1 == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	//......
	//关闭文件
	fclose(pf1);
	return 0;
}

3）文件打开结果

调整一下（为了进一步理解相对路径和绝对路径，这里的filename使用绝对路径的方式）

刚刚我们是以“读”的方式来打开文件，现在我们来尝试用“写”的方式来打开文件

#include<stdio.h>
int main()
{
	FILE* pf = fopen("file1.dat", "w");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	//写文件
	//... 
	printf("open file success!\n");
	//关闭文件
	fclose(pf);
}

在我们刚刚的路径下是没有file1.dat这个文件的，因为我们用“w”的方式打开文件，所以会创建一个新的文件

---

⛳2.文件的顺序读写

①fputc函数 与 fgetc函数

(1)举例 ：fput写入字符

int main()
{
	
	FILE* pf = fopen("FILE.txt", "w");	
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	fputc('T', pf);
	fputc('E', pf);
	fputc('X', pf);
	fputc('T', pf);


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

写入成功

---

(2)举例 ：fgetc写入字符

#include<stdio.h>
#include <errno.h>
#include <string.h>

int main()
{
	
	FILE* pf = fopen("FILE.txt", "r");	
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	printf("%c ", fgetc(pf));//T
	printf("%c ", fgetc(pf));//E
	printf("%c ", fgetc(pf));//X
	printf("%c ", fgetc(pf));//T

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

成功输出

---

②流（stream）的概念

输入输出是数据传送的过程, 数据如流水一样从一处流向另一处, 因此常将输入输出形象地称为流(stream), 即数据流。

流表示了信息从源到目的端的流动。在输入操作时, 数据从文件流向计算机内存, 在输出操作时, 数据从计算机流向文件(如打印机、磁盘文件)。文件是由操作系统进行统一管理的, 无论是用Word打开或保存文件, 还是C程序中的输入输出都是通过操作系统进行的。“流”是一个传输通道, 数据可以从运行环境(有关设备)流入程序中, 或从程序流至运行环境。

C语言把文件看作一个字符(或字节)的序列, 即由一个一个字符(或字节)的数据顺序组成。一个输入输出流就是一个字符流或字节(内容为二进制数据)流。 C的数据文件由一连串的字符(或字节)组成, 而不考虑行的界限, 两行数据间不会自动加分隔符,对文件的存取是以字符(字节)为单位的。输入输出数据流的开始和结束仅受程序控制而不受物理符号(如回车换行符)控制, 这就增加了处理的灵活性。 这种文件称为流式文件。

*C语言程序，只要运行起来，就默认打开了三个流，类型均为FILE

stdin-- - 标准输入流-- - 键盘 stdout-- - 标准输出流-- - 屏幕 stderr-- - 标准错误流-- - 屏幕

---

知道这个概念有个想法，他就可以从键盘上输入然后屏幕读出来

看下面代码例子：

---

接下来我们进行读文件，将生成的文件读出来

刚刚这种是从文件里面读，我们也可以从标准输入流stdin–键盘读

上面说的fputc\fgetc都是一个个字符方式读取的，如果要用这两个函数来处理字符串的话，效率就会非常低，那么用没用类似于这两个函数，但是可以一行一行读取的函数呢？

---

③fgets（读取） 与 fputs（写入）函数

这两个函数就是用来实现刚刚说的功能的。

举例fgets :

1）我们在文档中输入

2)我们使用fgets读取文件信息

#include<stdio.h>
#include <errno.h>
#include <string.h>

int main()
{
	char buf[1024] = { 0 };

	FILE* pf = fopen("FILE.txt", "r");

	if (pf == NULL)
	{
		printf("%c ", strerror(errno));
		return 0;
	}
	
	//一行一行的读数据
	fgets(buf, 1024, pf);
	printf("%s", buf);

	//再写一遍可以读取下一行
	fgets(buf, 1024, pf);
	printf("%s", buf);


	fclose(pf);
	pf = NULL;
}

---

举例二 ：fputs输入数据到文件中

1）使用fputs输入 HELLO WORLD

int main()
{
	FILE* pf = fopen("FILE.txt", "w");

	if (pf == NULL)
	{
		printf("%c ", strerror(errno));
		return 0;
	}
	
	fputs("HELLO WORLD", pf);


	fclose(pf);
	pf = NULL;
}

2 ）文本里面内容被修改

注意：

如果想要写入的字符串换行，则需要在字符串内容中添加换行‘\n’

---

举例3 : 从键盘上读取一行文本

#include<stdio.h>
#include <errno.h>
#include <string.h>

int main()
{

	char buf[1024] = { 0 };
	fgets(buf, 1024, stdin);//从标准输入流读取
	fputs(buf, stdout);//从标准输出流输出

	//上面写法等价于下面这种写法
	//gets(buf);
	//puts(buf);
}

---

④fscanf（读取）与fprintf（写入）函数

**前面进行的是字符的输入输出, 而实际上数据的类型是丰富的。**大家已很熟悉用printf 函数和scanf 函数向终端进行格式化的输入输出, 即用各种不同的格式以终端为对象输入输出数据。其实也可以对文件进行格式化输入输出, 这时就要用fprintf函数和 fscanf函数, 从函数名可以看到, 它们只是在printf和 scanf的前面加了一个字母f。它们的作用与printf 函数和scanf函数相仿, 都是格式化读写函数。

只有一点不同: fprintf 和 fscanf 函数的读写对象不是终端而是文件。

**它们的一般调用方式为 : **

fprintf(文件指针, 格式字符串, 输出表列); fscanf(文件指针, 格式字符串, 输入表列);

函数格式就是这样

就比printf前面多了一个流

fprintf(pf, "%d,%f", i, f);

1）举例1 ：fprintf函数写数据到文件里

#include<stdio.h>
#include <errno.h>
#include <string.h>

struct S 
{
	int a;
	float b;
	char arr[10];
};

int main()
{
	struct S s = { 10,3.1415,"hehe"};
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		return 0;
	}

	//格式化写文件
	fprintf(pf, "%d %f %s", s.a,s.b,s.arr);

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

结果展示：

---

2）举例2：fscanf(读取)函数得到文件数据

现在我们将输出的结构体文件重新读入到结构体变量中：

#include<stdio.h>
#include <errno.h>
#include <string.h>

struct S 
{
	int a;
	float b;
	char arr[10];
};

int main()
{
	struct S s = { 10,3.1415,"hehe"};
	FILE* pf = fopen("text.txt", "w");
	if (pf == NULL)
	{
		return 0;
	}

	//格式化的输入函数（读取）
	fscanf(pf, "%d %f %s", &(s.a), &(s.b), s.arr);//读到的数据放到结构体中
	printf("%d %f %s", s.a, s.b, s.arr);

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

当然我们也可以用fprintf，stdout是标准输出流，也就是屏幕

#include<stdio.h>
#include <errno.h>
#include <string.h>

struct S 
{
	int a;
	float b;
	char arr[10];
};

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

	//从键盘上读取，从屏幕上输出
	fscanf(stdin, "%d %f %s", &(s.a), &(s.b), &(s.arr));
	fprintf(stdout, "%d %f %s", s.a, s.b, s.arr);
}

上面我们说谈到的输入和输出实际上都是以文本数据的形式，也就是ASCII码形式。

---

⑤fread(二进制输出) 与fwrite(二进制输出)

在程序中不仅需要一次输入输出一个数据, 而且常常需要一次输入输出一组数据(如数组或结构体变量的值),C语言允许用fread函数从文件中读一个数据块, 用fwrite函数向文件写一个数据块。在读写时是以二进制形式进行的。在向磁盘写数据时, 直接将内存中一组数据原封不动、不加转换地复制到磁盘文件上, 在读入时也是将磁盘文件中若干字节的内容一批读入内存。

函数原型 :

fread( buffer，size, count, fp );

fwrite( buffer, size, count, fp );

注意：

1）buffer:是一个地址。 对fread来说, 它是用来存放从文件读入的数据的存储区的地址。 对fwrite来说,是要把此地址开始的存储区中的数据向文件输出(以上指的是起始地址)。

2）size : 要读写的字节数。

3）count : 要读写多少个数据项(每个数据项长度为size)。

4） fp : FILE类型指针。 在打开文件时指定用二进制文件, 这样就可以用fread和 fwrite函数读写任何类型的信息。

举例（一） :fwrite函数写入二进制数据进文件中

#include<stdio.h>

struct S
{
	char name[20];
	int age;
	double score;
};
int main()
{
	struct S s = { "张三",20,55.6 };
	FILE* pf = fopen("text.txt", "wb");//以二进制写是 “ wb ”
	if (pf == NULL)
	{
		return 0;
	}

	//以二进制写文件
	fwrite(&s, sizeof(struct S), 1, pf);


	fclose(pf);
	pf = NULL;

	return 0;
}

结果展示：

---

举例（二） ：fread函数读取文件中的二进制，并打印

#include<stdio.h>

struct S
{
	char name[20];
	int age;
	double score;
};
int main()
{
	struct S s = { "张三",20,55.6 };
	struct S tmp = { 0 };

	FILE* pf = fopen("text.txt", "rb");//以二进制读 是 “ rb ”
	if (pf == NULL)
	{
		return 0;
	}

	//以二进制读文件
	fread(&tmp, sizeof(struct S), 1, pf);
	//打印读的文件
	printf("%s %d %lf", , tmp.age, tmp.score);

	fclose(pf);
	pf = NULL;

	return 0;
}

---

⑥对比一组函数

scanf / fscanf / sscanf printf / fprintf / sprintf

scanf与printf是一组-- - 从标准输入流（stdin） / 输出流（stdout）中输入 / 输出格式化的数据

fscanf与fprintf一组-- - 从所有流类型（包括标准输入流\输出流，文件流等各种流）输入 / 输出格式化的数据

sscanf与sprintf一组-- - 从一个字符串中输入 / 输出格式化数据

函数原型

int sscanf(const char* buffer, const char* format[, argument] …); 

int sprintf(char* buffer,const char* format[, argument] …);

sscanf 与 sprintf 使用举例：

#include<stdio.h>
struct S
{
	char ch[15];
	int age;
	float f;
};
int main()
{

	struct S s = { "Hello_world",20,5.5 };
	struct S temp = { 0 };
	char buffer[100] = { 0 };
    
    //将一个结构体的数据转换成一个字符串，写到buffer中
	sprintf(buffer, "%s %d %f", s.ch, s.age, s.f);
	printf("%s\n", buffer);
    
	//将buffer的字符串读取，写入其中成一个结构体
	sscanf(buffer, "%s %d %f", temp.ch, &(temp.age), &(temp.f));
	printf("%s %d %f\n", temp.ch, temp.age, temp.f);

	return 0;
}

---

⚽3.文件随机读取

一般情况下, 在对字符文件进行顺序读写时, 文件位置标记指向文件开头, 这时如果对文件进行读的操作, 就读第1个字符, 然后文件位置标记向后移一个位置, 在下一次执行读的操作时, 就将位置标记指向的第⒉个字符读入。依此类推, 遇到文件尾结束。

可以根据读写的需要, 人为地移动文件位置标记的位置。文件位置标记可以向前移、向后移, 移到文件头或文件尾, 然后对该位置进行读写, 显然这就不是顺序读写了, 而是随机读写。

---

①fseek函数

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

函数原型：

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

fseek(文件类型指针, 偏移量, 起始点)
    

起始点的选项有三个

---

举例：

1）准备文件，输入一串字符

2）使用 fseek函数

#include<stdio.h>

int main()
{


	FILE* pf = fopen("text.txt", "r");//abcdefg
	if (pf == NULL)
	{
		return 0;
	}

	//1.定位文件指针
	fseek(pf, 2, SEEK_CUR);//从当前位置

	//2.读取文件
	int ch = fgetc(pf);
	printf("%c\n", ch);//c
	ch = fgetc(pf);
	printf("%c\n", ch);//d
	ch = fgetc(pf);
	printf("%c\n", ch);//e


	fclose(pf);
	pf = NULL;

	return 0;
}

3）运行结果

---

现在我们运用fseek函数对当前文件指针位置进行偏移，

比如：

本来pf读了a之后，应该移动到b的位置，但是用fseek让其偏移 - 1，也就是向左偏移一个位置（一个字节），又回到了a。

当起始点为SEEK_END 的时候，只能向左（向前）偏移，也就是偏移量只能为负值 当起始点为SEEK_SET 的时候，只能向右（向后）偏移，也就是偏移量只能为正值

---

②ftell函数

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

函数原型：

long int fte11(FILE * stream);

举例：

int main()
{


	FILE* pf = fopen("text.txt", "r");//abcdefg
	if (pf == NULL)
	{
		return 0;
	}

	//1.定位文件指针
	fseek(pf, 2, SEEK_CUR);//从当前位置

	//2.读取文件
	int ch = fgetc(pf);
	printf("%c\n", ch);//c
	ch = fgetc(pf);
	printf("%c\n", ch);//d
	ch = fgetc(pf);
	printf("%c\n", ch);//e

	//确定当前位置偏移量
	int pos = ftell(pf);
	printf("%d", pos);

	fclose(pf);
	pf = NULL;

	return 0;
}

---

③rewind函数

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

函数原型：

void rewind(FILE * stream);

举例 ;

#include<stdio.h>

int main()
{


	FILE* pf = fopen("text.txt", "r");//abcdefg
	if (pf == NULL)
	{
		return 0;
	}

	//1.定位文件指针
	fseek(pf, 2, SEEK_CUR);// c位置

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

	rewind(pf);//回到起始位置
	ch = getc(pf);
	printf("%c\n", ch);//a

	fclose(pf);
	pf = NULL;

	return 0;
}

结果展示：

---

⌚4.文件结束判定

①feof函数

常被被错误使用的feof函数

牢记 : 在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

1. 文本文件读取是否结束，判断返回值是否为EOF （fgetc），或者NULL（fgets） 例如： fgetc判断是否为EOF. fgets判断返回值是否为NULL.
2. 二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。 例如： fread判断返回值是否小于实际要读的个数

例如∶

1.fread判断返回值是否小于实际要读的个数。 fgetc函数在读取结束的时候，会返回EOF 正常读取的时候，返回的是字符的AscII码值

2.fgets函数在读取结束的时候，会返回NULL 正常读取的是时候，返回存放字符串的空间起始地址。

3.fread函数在读取的时候，返回的是实际读取到的完整元素的个数，如果发现读取到的完整元素的个数小于实际要读取（指定要读取）的个数，这就是最后一次读取了。

---

举例： （1）先创建一个test.txt文件，然后在里面随便编辑点内容进行保存

2）编写代码，将刚刚test.txt文件的内容读出来放到一个新文件test2.txt当中（相当于复制拷贝一份test.txt）

#include<stdio.h>
int main()
{
	FILE* pfread = fopen("test.txt", "r");
	if (pfread == NULL)
	{
		perror("fopne");
		return 1;
	}
	FILE* pfwrite = fopen("test2.txt", "w");
	if (pfwrite == NULL)
	{
		//退出前要先关闭打开的pfread
		fclose(pfread);
		pfread = NULL;
		perror("fopen");
		return 1;
	}
	if (feof(pfread))
	{
		printf("遇到文件结束标志，正常结束\n");
	}
	else if (ferror(pfread))
	{
		printf("文件读取失败结束！\n");
	}
	//文件都正常打开
	int ch = 0;
	while ((ch = fgetc(pfread)) != EOF)
	{
		//写文件
		fputc(ch, pfwrite);
	}
	return 0;
}

程序运行后，在源文件路径下生成test2.txt

打开test.txt和test2.txt进行对比，会发现两者是一样的

---

代码举例:文本文件

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

---

代码举例:二进制文件

#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("Error reading test.bin: unexpected end of file\n"); 
    
    else if (ferror(fp))
    {
	perror("Error reading test.bin");
	}
    
	fclose(fp); 
    fp = NULL;
}