c语言文件读写操作
 
一、文件指针File
 
1.定义
 
FILE类型是系统预先设定的一种结构体指针
FILE* 指针作为文件句柄，是文件访问的唯一标识，它由fopen函数创建，fopen打开文件成功，则返回一个有效的FILE*指针，否则返回空指针NULL
定义方式
 FILE *fp=fopen(char *filename,char *mode);
 或
 FILE *fp;
 fp=fopen(char *filename,char *mode); 
  
 
   
FILE * fopen(char* filename,char* mode)
 filename:文件名，如“students.txt”。 相对路径
 mode:打开方式（读写方式，文件类型）
 
  
 
 
 
2.文件类型分类
 
文本文件：这类文件以文本的ASCII、UNICODE(万国码)等编码形式存储在计算机中。它是以"行"为基本结构的一种信息组织和存储方式。
二进制文件：这类文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们，只有通过相应的软件才能将其显示出来。二进制文件一般是可执行程序、图形、图像、声音等等。
 
3.文件打开方式
 
"r"正文文件只读方式打开。文件不存在，则打开失败
"w"正文文件只写方式打开。若文件不存在，则建立文件；若文件存在，则删除文件内容，重建空文件
"a"正文文件添加方式。文件不存在，则建立文件
"r+ ":正文文件读写打开，文件不存在，则打开失败
"w+ " :正文文件读写方式打开，文件不存在，则建立文件
 
4.文件打开
 
#include <stdio.h>
int main()
{
    FILE *fp; /*文件指针*/
    fp=fopen("member.txt","rb");
    if(fp==NULL)
        printf("提示:文件未能成功打开");
    else
        printf("提示:文件已经打开");
    return 0;
} 
 
 
 
Warning!
 使用fopen时，但凡含r字母的打开方式，一定要加判断，文件是否打开成功，否则程序不会报告错误，会运行下去。如：
 
 
FILE *fr; 
fr=fopen("abc.txt","r"); 
if(fr==NULL){
printf("File not open!/n"); 
 
5.文件关闭
 
 
 
fclose(FILE *fp)
 一般地，fclose(fp)应与fopen配对使用，特别是含有写方式的文件，若不关闭，可能会造成文件数据丢失。
 
 
二、一般读写函数
 
 
 
字符的读写函数：fgetc()函数和fputc()函数
 字符串的读写函数：fgets()函数和fputs()函数
 数据块的读写函数，主要针对二进制文件：fread()函数和fwrite()函数
 格式化的读写函数，主要针对文本文件：fscanf()函数和fprintf()函数
 
 
字符串读写
 
1、fputs()函数
 
格式：fputs(s,fp);
 功能：用来将一个字符串写入指定的文本文件。
 其中，fp为文件指针，s可以是字符数组名，字符型指针变量或字符串常量。该函数的功能是将字符串s写入由fp指向的文件中，字符串末尾的‘\0’字符不允写入。
 返回值：执行成功，返回所写的最后一个字符；否则，返回EOF。
 
//fputs

#include <stdio.h>
#include <stdlib.h>
void main(){
    FILE *fp;
    char s[][15]={"BeiJing","ShangHai","GuangZhou","NanJing","HangZhou"};
    if((fp=fopen("c:\\1\\wenjiu3.txt","w"))==NULL)
    /*只能相应文件，创建不了文件夹，fopen()函数会寻找相应位置文件夹然后在其中创建所需文件。
    当没有所需文件夹的时候，系统会自动跳转到NULL!*/
    {
        printf("Cannot open the file,strike any key to exit!\n");
        getchar();
        exit(0);
    }
    for(int i=0;i<6;i++){
        fputs(s[i],fp);
        fputs("\n",fp);
    }
    fclose(fp);
}//输出在文件中的第六行，会出现“'jb”这个字符串
 
2、fgets()函数
 
格式：fgets(s,n,fp);
 
功能：用于从指定的文件中读一个字符串到字符数组中。
 
其中，s可以是字符型数组名或字符串指针,n是指定读入的字符个数；fp为文件指针。n是一个正整数，表示从文件中最多读取n-1个字符，并将字符串指针s定位在读入的字符串首地址。fgets()函数从文件中读取字符直到遇到回车符或EOF为止，函数会在最后一个字符后加上字符串结束标志’\0’；若有EOF，则不予保留。
 
返回值：该函数如果执行成功，返回读取字符串；如果失败，则返回空指针NULL，这时，s中的内容不确定。
 
//fgets()函数

#include <stdio.h>
#include <stdlib.h>
void main(){
    FILE *fp;
    char s[6][15];
    if((fp=fopen("c:\\1\\wenjiu3.txt","r"))==NULL){
        printf("Cannot open the file,strike any key to exit!\n");
        getchar();
        exit(0);
    }
    for(int i=0;i<6;i++){
        fgets(s[i],15,fp);
        if(i%2==0)
            printf("%s",s[i]);
    }
    fclose(fp);
}
 
格式化读写
 
1.fprintf()函数
 
格式：fprintf(fp, format, arg1, arg2,….,argn);
 
功能：fprintf()用来将输出项按指定的格式写入指定的文本文件中，其中格式化规定与printf()函数功能相似，所不同的只是fprintf()函数是将输出的内容写入文件中，而printf()函数则是在屏幕输出。
 
其中，fp为文件指针，format为指定的格式控制字符串；arg1~argn为输出项，可以是字符、 字符串或各种类型的数值。该函数的功能是按格式控制字符串format给定的格式，将输出项arg1,arg2,……,argn的值写入fp所指向的文件中。
 
返回值：如果函数执行成功，返回实际写入文件的字符个数；若出现错误，返回负数。
 
 
 
fprintf()中格式控制的使用与printf()相同。
 例如：fprintf(fp,”r=%f,area=%f\n”,r,area);
 
 
//fprintf()函数

#include <stdio.h>
#include <stdlib.h>
void main(){
    FILE *fp;
    int data[1000];
    for(int i=0;i<1000;i++)
        data[i]=(rand()%1000);//产生0~999的随机整数
    if((fp=fopen("c:\\1\\wenjiu5.txt","w"))==NULL){
        printf("Cannot open the file,strike any key to exit!\n");
        getchar();
        exit(0);
    }
    for(i=0;i<1000;i++){
        if(i%20==0)
            fprintf(fp,"\n%5d",data[i]);
        else
            fprintf(fp,",%5d",data[i]);
        if((i+1)%20==0)
            fprintf(fp,"\n");
    }
    fclose(fp);

}
 
2、fscanf()函数
 
格式：fscanf(fp,format,arg1,arg2,……,argn);
 
功能：fscanf()用来按规定的格式从指定的文本文件中读取数据。它与scanf()函数的功能相似，都是按规定的格式读数据的函数，只是fscanf()函数读的对象不是键盘区，而是文件。
 
其中，fp为文件指针，format为指定的格式控制字符串；arg1~argn为输入项的地址。该函数的功能是从文件指针fp所指的文本文件中读取数据，按格式控制字符串format给定的格式赋予输入项arg1,arg2,……,argn中。
 
返回值：如果该函数执行成功，返回读取项目个数；如果遇到文件末尾，返回EOF;如果赋值失败，返回0.
 
 
 
fscanf()中格式控制的使用与scanf()相同。
 例如：fprintf(fp,”%d,%d\n”,&a,&b);
 
 
//fscanf()函数

#include <stdio.h>
#include <stdlib.h>
void main(){
    FILE *fp;
    int data[1000];
    if((fp=fopen("c:\\1\\wenjiu5.txt","r+"))==NULL){
        printf("Cannot open the file,strike any key to exit!\n");
        getchar();
        exit(0);
    }
    for(int i=0;i<1000;i++){
        if(i%20==0)
            fscanf(fp,"\n%5d",&data[i]);
        else
            fscanf(fp,",%5d",&data[i]);
    }
    fseek(fp,0,SEEK_END);
    fprintf(fp,"\n\n");
    int j=0;
    for(i=0;i<1000;i++){
        {
            if(data[i]%7==0)
            {
                if(j%20==0)
                    fprintf(fp,"%5d",data[i]);
                if((j+1)%20==0) fprintf(fp,"\n");
                j++;
            }
        }
        fclose(fp);
    }
}
 
结语
 
第一次发表博客，还有点小激动，虽然不是原创，从网上几篇文章整理的，就是复习了一下c语言文字文件读写操作，也供自己以后回顾。

文件的打开函数fopen()
 
文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区，并将该结构的指针返回给用户程序，以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。当使用打开函数时，必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在，就意味着建立(只对写文件而言，对读文件则出错)，并将文件指针指向文件开头。若已有一个同名文件存在，则删除该文件，若无同名文件，则建立该文件，并将文件指针指向文件开头。
 
fopen(char *filename,char *type);
 
其中filename是要打开文件的文件名指针，一般用双引号括起来的文件名表示，也可使用双反斜杠隔开的路径名。而type参数表示了对打开文件的操作方式。其可采用的操作方式如下： 方式 含义 “r” 打开，只读； “w” 打开，文件指针指到头，只写； “a” 打开，指向文件尾，在已存在文件中追加； “rb” 打开一个二进制文件，只读； “wb” 打开一个二进制文件，只写； “ab” 打开一个二进制文件，进行追加 ；“r+” 以读/写方式打开一个已存在的文件； “w+” 以读/写方式建立一个新的文本文件 ；“a+” 以读/写方式打开一个文件文件进行追加 ；“rb+” 以读/写方式打开一个二进制文件； “wb+” 以读/写方式建立一个新的二进制文件 ；“ab+” 以读/写方式打开一个二进制文件进行追加 ；当用fopen()成功的打开一个文件时，该函数将返回一个FILE指针，如果文件打开失败，将返回一个NULL指针。
 
关闭文件函数fclose()
 
文件操作完成后，必须要用fclose()函数进行关闭，这是因为对打开的文件进行写入时，若文件缓冲区的空间未被写入的内容填满，这些内容不会写到打开的文件中去而丢失。只有对打开的文件进行关闭操作时，停留在文件缓冲区的内容才能写到该文件中去，从而使文件完整。再者一旦关闭了文件，该文件对应的FILE结构将被释放，从而使关闭的文件得到保护，因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。
 
int fclose(FILE *stream);
 
它表示该函数将关闭FILE指针对应的文件，并返回一个整数值。若成功地关闭了文件，则返回一个0值，否则返回一个非0值。
 
int read(int handle, void *buf, int count);
 read()函数从handle(文件描述字)相连的文件中, 读取count个字节放到buf所指的缓冲区中, 返回值为实际所读字节数, 返回-1表示出错。返回0 表示文件结束。
 
write()函数的调用格式为:
 int write(int handle, void *buf, int count);
 write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中, 返回值为实际写入的字节数。
 
size_t fread( void *buffer, size_t size, size_t count, FILE *stream )
 buffer 是读取的数据存放的内存的指针（可以是数组，也可以是新开辟的空间，buffer就是一个索引）
 size 是每次读取的字节数
 count 是读取次数
 stream 是要读取的文件的指针
 
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
 
其中，ptr：指向保存数据的指针；size：每个数据类型的大小；count：数据的个数；stream：文件指针 ； 函数返回写入数据的个数。
 
fseek
 函数名: fseek
 功 能: 重定位流上的文件指针
 用 法: int fseek(FILE *stream, long offset, int fromwhere);
 描 述: 函数设置文件指针stream的位置。如果执行成功，stream将指向以fromwhere为基准，偏移offset个字 节的位置。如果执行失败(比如offset超过文件自身大小)，则不改变stream指向的位置。
 返回值: 成功，返回0，否则返回其他值。
 fromwhere有三个可选值：SEEK_SET 开始 SEEK_CUR现在指针所指的位置 SEEK_END末尾
 
ftell
 用于得到二进制文件位置指针当前位置相对于文件首的偏移字节数。在随机方式存取文件时，由于文件位置频繁的前后移动，程序不容易确定文件的当前位置。
 long ftell(FILE *stream);
 
int fprintf(FILE *stream,char *format,variable-list)
 int fscanf(FILE *stream,char *format,variable-list)
 fprintf()则是向流指针指向的文件输出；fscanf()是从文件输入
 
简单的例子：先读取文件内容，再向文件写数据
 
#include "pch.h"
#include <iostream>
#include<stdio.h>
#include<stdlib.h>

using namespace std;
int main()
{
	const char *filename ="test.txt";
	FILE *fp;
	//以追加读写的方式打开文件
	fopen_s(&fp,"test.txt","ab+");
	if (!fp) {
		printf("open file %s failed!", filename);
	}
	//统计文件大小
	fseek(fp,0,SEEK_END);  
	int len = ftell(fp);
	//若使用fseek，ftell统计文件大小，那么在获得大小后要将指针移回原来的位置，因为fseek会改变指针的位置
	fseek(fp,0,0);  
	//保存从文件中读去的数据
	char buf[10000] = {0};
	//读取文件
	fread(buf,len,1,fp);
	//关闭
	fclose(fp); 
	//重新打开，不然会写入失败，不知道为什么
	fopen_s(&fp, "test.txt", "ab+"); 
	cout << buf << endl;
	//保存写入文件的内容
	char writebuf[1024];
	char ch = 0;
	int i = 0;
	//读取输入字符，以换行符结束
	while ((ch=getchar())!='\n') {
		writebuf[i++] = ch;
	}
	writebuf[i++] = '\n';
	writebuf[i++] = '\0';
	//向文件末尾添加数据
	int flen=fwrite(writebuf,i,1,fp);
	//关闭数据
	fclose(fp);
	return 0;
}

数据流和缓冲区是什么？文件类型和文件存取方式都有啥？
 
数据流
 就C程序而言，从程序移进，移出字节，这种字节流就叫做流。程序与数据的交互是以流的形式进行的。进行C语言文件的读写时，都会先进行“打开文件”操作，这个操作就是在打开数据流，而“关闭文件”操作就是关闭数据流。
缓冲区
 在程序执行时，所提供的额外内存，可用来暂时存放准备执行的数据。它的设置是为了提高存取效率，因为内存的存取速度比磁盘驱动器快得多。
 当使用标准I/O函数(包含在头文件stdio.h中)时，系统会自动设置缓冲区，并通过数据流来读写文件。当进行文件读取时，是先打开数据流，将磁盘上的文件信息拷贝到缓冲区内，然后程序再从缓冲区中读取所需数据。事实上，当写入文件时，并不会马上写入磁盘中，而是先写入缓冲区，只有在缓冲区已满或“关闭文件”时，才会将数据写入磁盘。
文件类型
 文本文件和二进制文件：
 文本文件是以字符编码的方式进行保存的。
 二进制文件将内存中的数据原封不动的进行保存，适用于非字符为主的数据。其实，所有的数据都可以算是二进制文件。二进制文件的优点在于存取速度快，占用空间小。
文件存取方式
 顺序存取方式和随机存取方式：
 顺序存取就是从上往下，一笔一笔读取文件的内容。写入数据时，将数据附加在文件的末尾。这种存取方式常用于文本文件。
 随机存取方式多半以二进制文件为主。它会以一个完整的单位来进行数据的读取和写入，通常以结构为单位。
 
什么是文件呢？
 
文件是一段数据的集合，这些数据可以是有规则的，也可以是无序的集合。在stdio.h有一个非常重要的东西，文件指针，每个文件都会在内存中开辟一块空间，用于存放文件的相关信息，这些信息保存在一个结构体中：
 struct _iobuf {
 char *_ptr; //指向buffer中第一个未读的字节
 int _cnt; //记录剩余的未读字节的个数
 char *_base;//文件的缓冲
 int _flag;//打开文件的属性
 int _file;//获取文件描述
 int _charbuf;//单字节的缓冲，即缓冲大小仅为1个字节
 int _bufsiz;//记录这个缓冲大小
 char *_tmpfname;//临时文件名
 };
 typedef struct _iobuf FILE;
 FILE是一个数据结构，用于访问一个流。每个流都会对应一个FILE结构体。
 
C语言文件操作函数详解
 
C语言中没有输入输出语句，所有的输入输出功能都用 ANSI C提供的一组标准库函数来实现。文件操作标准库函数有：
 
文件的打开
 fopen()：打开文件
文件的关闭
 fclose()：关闭文件
文件的读写
 fgetc()：读取一个字符
 fputc()：写入一个字符
 fgets()：读取一个字符串
 fputs()：写入一个字符串
 fprintf()：写入格式化数据
 fscanf()：格式化读取数据
 fread()：读取数据
 fwrite()：写入数据
文件状态检查
 feof()：文件是否结束
 ferror()：文件读/写是否出错
 clearerr()：清除文件错误标志
 ftell()：文件指针的当前位置
文件指针定位
 rewind()：把文件指针移到开始处
 fseek()：重定位文件指针
 
参数解释：
 “r”：以只读的形式打开文本文件(不存在则出错)
 “w”：以只写的形式打开文本文件(若不存在则新建，反之，则从文件起始位置写，覆盖原内容)
 “a”：以追加的形式打开文本文件(若不存在，则新建；反之，在原文件后追加)
 “r+”：以读写的形式打开文本文件(读时，从头开始；写时，新数据只覆盖所占的空间)
 “wb”：以只写的形式打开二进制文件
 “rb”：以只读的形式打开二进制文件
 “ab”：以追加的形式打开一个二进制文件
 “rb+”：以读写的形式打开二进制文件。
 “w+”：首先建立一个新文件，进行写操作，然后从头开始读(若文件存在，原内容将全部消失)
 “a+”：功能与”a”相同。只是在文件尾部追加数据后，可以从头开始读
 “wb+”：功能与”w+”相同。只是在读写时，可以由位置函数设置读和写的起始位置
 “ab+”：功能与”a+”相同。只是在文件尾部追加数据之后，可以由位置函数设置开始读的起始位置
 
打开文件
 FILE *fopen( const char *filename, const char *mode );
 
filename：文件的路径
mode：打开模式
 
例：
 
int main()
{
    FILE* f;
    f = fopen("file.txt", "w");
    if (f != NULL)
    {
        fputs("fopen example", f);
        fclose(f);
        f=NULL;
    }
    return 0;
}
 
注意:
 
文件是否打开成功
关闭文件
文件指针置空
 
关闭文件
 函数原型：int fclose( FILE *stream );
 
stream：流
 
例：
 
if(fclose(f)!=0) 
{
	printf("File cannot be closed/n"); 
	exit(1); 
} 
else
{
    printf("File is now closed/n"); 
}
 
读取字符
 int fgetc ( FILE * stream );
 
stream：流
 
例：
 
#include <stdio.h>
int main ()
{
  FILE * pFile;
  int c;
  int n = 0;
  pFile = fopen ("D:\\myfile.txt", "r");
  if (pFile == NULL) perror ("Error opening file"); // 打开失败
  else
  {
    while (c != EOF)
    {
      c = fgetc (pFile); // 获取一个字符
      if (c == '$') n++; // 统计美元符号 '$' 在文件中出现的次数
    }
    fclose (pFile); // 一定记得要关闭文件
    printf ("The file contains %d dollar sign characters ($).\n",n);
  }
  return 0;
}
 
写入字符
 int fputc( int c, FILE *stream );
 
c：要写入的字符
stream：流
 
例：
 
    char ch;
    FILE* pf = fopen("file.txt", "w");
    if (pf == NULL)
    {
        perror("error opening file");
        exit(0);
    }
    ch = getchar();
    while (ch != '$')
    {
        fputc(ch, pf);
        ch = getchar();
    }
    fclose(pf);
 
读取字符串
 char * fgets ( char * str, int num, FILE * stream );
 
str：将读取到的内容复制到的目标字符串
num：一次读取的大小
stream：流
 
例：
 
    char buf[10] = { 0 };
    FILE *pf = fopen("file.txt", "r");
    if (pf == NULL)
    {
        perror("open file for reading");
        exit(0);
    }
    fgets(buf, 9, stdin);
    printf("%s", buf);
    fclose(pf);
 
写入字符串
 int fputs( const char *string, FILE *stream );
 
string：要写入的字符串
stream：一次读取的大小
 
例：
 
    char buf[10] = { 0 };
    FILE *pf = fopen("file.txt", "r");
    if (pf == NULL)
    {
        perror("open file for reading");
        exit(0);
    }
    fgets(buf, 9, stdin);
    fputs(buf, stdout);
    fclose(pf);
 
读取数据块
 size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
 
ptr：目标内存块
size：一次读取的字节大小
count：一次读取多少个 size
stream：流
 
例：
 
#include <stdio.h>
#include <string.h>
 
int main()
{
    FILE *pFile = fopen("file.txt", "rb");
    if (pFile == NULL) 
    {
        perror ("Error opening file");
        return 0;
    }
    char buf[100] = { 0 };
    while (!feof(pFile)) //没有到文件末尾
    {
        memset(buf, 0, sizeof(buf));
        size_t len = fread(buf, sizeof(char), sizeof(buf), pFile);
        printf("buf: %s, len: %d\n", buf, len);
    }
    fclose(pFile);
}
 
写入数据块
 size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
 同理，简单好理解，就不详细阐述了。
 
文件指针重定位
 int fseek ( FILE * stream, long int offset, int origin );
 
stream：流
offset：相对应 origin 位置处的偏移量，单位为字节
origin：指针的位置
 #define SEEK_CUR 1 // 当前位置
 #define SEEK_END 2 // 末尾
 #define SEEK_SET 0 // 开头
 
获取指针位置
 long int ftell ( FILE * stream );
 
stream：流
 
获取文件大小
 例：
 
long n;
fseek(pf,0,SEEK_END);
n=ftell(pf);
 
文件指针移到开始处
 void rewind( FILE *stream );
 
stream：流
 
清除文件错误标志
 void clearerr( FILE *stream );
 
stream：流
 
文件流是否读到了文件尾
 int feof( FILE *stream );
 
stream：流
 
重命名文件
 int rename ( const char * oldname, const char * newname );
 
oldname：原名
newname：新名
 
删除文件
 int remove ( const char * filename );
 
filename：文件的路径

转自：http://www.cnblogs.com/xiajun/archive/2010/08/14/2282881.html


 
C语言文件操作
 
一、标准文件的读写
 
1.文件的打开
 
fopen() 文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区，并将该结构的指针返回给用户程序，以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。当使用打开函数时，必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在，就意味着建立(只对写文件而言，对读文件则出错)，并将文件指针指向文件开头。若已有一个同名文件存在，则删除该文件，若无同名文件，则建立该文件，并将文件指针指向文件开头。

 
fopen(char *filename,char *type); 

 
其中*filename是要打开文件的文件名指针，一般用双引号括起来的文件名表示，也可使用双反斜杠隔开的路径名。而*type参数表示了对打开文件的操作方式。其可采用的操作方式如下： 方式 含义 "r" 打开，只读； "w" 打开，文件指针指到头，只写； "a" 打开，指向文件尾，在已存在文件中追加； "rb" 打开一个二进制文件，只读； "wb" 打开一个二进制文件，只写； "ab" 打开一个二进制文件，进行追加 ；"r+" 以读/写方式打开一个已存在的文件； "w+" 以读/写方式建立一个新的文本文件 ；"a+" 以读/写方式打开一个文件文件进行追加 ；"rb+" 以读/写方式打开一个二进制文件； "wb+" 以读/写方式建立一个新的二进制文件 ；"ab+" 以读/写方式打开一个二进制文件进行追加 ；当用fopen()成功的打开一个文件时，该函数将返回一个FILE指针，如果文件打开失败，将返回一个NULL指针。如想打开test文件，进行写：
 

  

   

    [cpp] 
    view plain
    copy
    print
    ?
   
  
  
FILE *fp;  
if((fp=fopen("test","w"))==NULL) {  
    printf("File cannot be opened/n");  
    exit();  
}  
else  
    printf("File opened for writing/n");  
……  
fclose(fp);   
 
 
DOS操作系统对同时打开的文件数目是有限制的，缺省值为5，可以通过修改CONFIG.SYS文件改变这个设置。
 
2.关闭文件函数fclose() 

 
文件操作完成后，必须要用fclose()函数进行关闭，这是因为对打开的文件进行写入时，若文件缓冲区的空间未被写入的内容填满，这些内容不会写到打开的文件中去而丢失。只有对打开的文件进行关闭操作时，停留在文件缓冲区的内容才能写到该文件中去，从而使文件完整。再者一旦关闭了文件，该文件对应的FILE结构将被释放，从而使关闭的文件得到保护，因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。
 
int fclose(FILE *stream); 
 
它表示该函数将关闭FILE指针对应的文件，并返回一个整数值。若成功地关闭了文件，则返回一个0值，否则返回一个非0值。常用以下方法进行测试：
 

  

   

    [cpp] 
    view plain
    copy
    print
    ?
   
  
  
if(fclose(fp)!=0) {  
    printf("File cannot be closed/n");   
    exit(1);   
}   
else  
    printf("File is now closed/n");   
 
 
当打开多个文件进行操作，而又要同时关闭时，可采用
 fcloseall()函数，它将关闭所有在程序中打开的文件。 int fcloseall(); 该函数将关闭所有已打开的文件，将各文件缓冲区未装满的内容写到相应的文件中去，接着释放这些缓冲区，并返回关闭文件的数目。如关闭了4个文件，则当执行：
  n=fcloseall(); 时，n应为4。
 
3.文件的读写
 
(1).读写文件中字符的函数(一次只读写文件中的一个字符)：
 
int fgetc(FILE *stream);
 
int getchar(void);
 
int fputc(int ch,FILE *stream);
 
int putchar(int ch); 

 
int getc(FILE *stream); 

 
int putc(int ch,FILE *stream); 

 
其中fgetc()函数将把由流指针指向的文件中的一个字符读出，例如： ch=fgetc(fp); 将把流指针fp指向的文件中的一个字符读出，并赋给ch，当执行fgetc()函数时，若当时文件指针指到文件尾，即遇到文件结束标志EOF(其对应值为-1)，该函数返回一个-1给ch，在程序中常用检查该函数返回值是否为-1来判断是否已读到文件尾，从而决定是否继续。
 

  

   

    [cpp] 
    view plain
    copy
    print
    ?
   
  
  
#include "stdio.h"   
#include <stdlib.h>  
int main() {   
    FILE *fp;   
    char ch;  
    if((fp=fopen("myfile.txt","r"))==NULL) {  
        printf("file cannot be opened/n");   
        exit(1);   
    }   
    while((ch=fgetc(fp))!=EOF)   
        fputc(ch,stdout);   
    fclose(fp);   
}   
 
 
该程序以只读方式打开myfile.txt文件，在执行while循环时，文件指针每循环一次后移一个字符位置。用fgetc()函数将文件指针指定的字符读到ch变量中，然后用fputc()函数在屏幕上显示，当读到文件结束标志EOF时，关闭该文件。 上面的程序用到了fputc()函数，该函数将字符变量ch的值写到流指针指定的文件中去，由于流指针用的是标准输出(显示器)的FILE指针stdout，故读出的字符将在显示器上显示。又比如： fputc(ch,fp); 该函数执行结构，将把ch表示的字符送到流指针fp指向的文件中去。 在TC中，putc()等价于fputc(),getc()等价于fgetc()。 putchar(c)相当于fputc(c,stdout)；getchar()相当于fgetc(stdin)。 注意，这里使用char ch,其实是不科学的，因为最后判断结束标志时，是看ch!=EOF,而EOF的值为-1，这显然和char是不能比较的。所以，某些使用，我们都定义成int ch。
 
(2).读写文件中字符串的函数
 
char *fgets(char *string,int n,FILE *stream); 

 
char *gets(char *s); 

 
int fprintf(FILE *stream,char *format,variable-list); 

 
int fputs(char *string,FILE *stream);
 
int fscanf(FILE *stream,char *format,variable-list); 

 
其中fgets()函数将把由流指针指定的文件中n-1个字符，读到由指针string指向的字符数组中去，例如： fgets(buffer,9,fp); 将把fp指向的文件中的8个字符读到buffer内存区，buffer可以是定义的字符数组，也可以是动态分配的内存区。 注意，fgets()函数读到'/n'就停止，而不管是否达到数目要求。同时在读取字符串的最后加上'/0'。 fgets()函数执行完以后，返回一个指向该串的指针。如果读到文件尾或出错，则均返回一个空指针NULL，所以长用feof()函数来测定是否到了文件尾或者是ferror()函数来测试是否出错，例如下面的程序用fgets()函数读test.txt文件中的第一行并显示出来：
 

  

   

    [cpp] 
    view plain
    copy
    print
    ?
   
  
  
#include "stdio.h"   
int main() {  
    FILE *fp;   
    char str[128];   
    if((fp=fopen("test.txt","r"))==NULL) {  
        printf("cannot open file/n"); exit(1);  
    }   
    while(!feof(fp)) {  
        if(fgets(str,128,fp)!=NULL)  
        printf("%s",str);  
    }  
    fclose(fp);  
}   
 
 
gets()函数执行时，只要未遇到换行符或文件结束标志，将一直读下去。因此读到什么时候为止，需要用户进行控制，否则可能造成存储区的溢出。 fputs()函数想指定文件写入一个由string指向的字符串，'/0'不写入文件。 fprintf()和fscanf()同printf()和scanf()函数类似，不同之处就是printf()函数是想显示器输出，fprintf()则是向流指针指向的文件输出；fscanf()是从文件输入。 下面程序是向文件test.dat里输入一些字符：
 

  

   

    [cpp] 
    view plain
    copy
    print
    ?
   
  
  
#include <stdio.h>  
#include <stdlib.h>  
int main() {  
    char *s="That's good news";   
    int i=617;   
    FILE *fp;  
    fp=fopen("test.dat", "w"); /*建立一个文字文件只写*/   
    fputs("Your score of TOEFL is",fp); /*向所建文件写入一串字符*/   
    fputc(':', fp); /*向所建文件写冒号:*/   
    fprintf(fp, "%d/n", i); /*向所建文件写一整型数*/   
    fprintf(fp, "%s", s); /*向所建文件写一字符串*/   
    fclose(fp);  
}   
 
 
用DOS的TYPE命令显示TEST.DAT的内容如下所示: 屏幕显示 Your score of TOEFL is: 617 That's good news 下面的程序是把上面的文件test.dat里的内容在屏幕上显示出来：
 

  

   

    [cpp] 
    view plain
    copy
    print
    ?
   
  
  
#include <stdio.h>  
int main() {  
    char s[24], m[20];   
    int i;  
    FILE *fp;  
    fp=fopen("test.dat", "r"); /*打开文字文件只读*/  
    fgets(s, 24, fp); /*从文件中读取23个字符*/  
    printf("%s", s);   
    fscanf(fp, "%d", &i); /*读取整型数*/  
    printf("%d", i);   
    putchar(fgetc(fp)); /*读取一个字符同时输出*/  
    fgets(m, 17, fp); /*读取16个字符*/   
    puts(m); /*输出所读字符串*/   
    fclose(fp);   
}   
 
 
运行后屏幕显示: Your score of TOEFL is: 617 That's good news
 
4.清除和设置文件缓冲区
 
(1).清除文件缓冲区函数：
 
 int fflush(FILE *stream); 
 
int flushall();
 
 fflush()函数将清除由stream指向的文件缓冲区里的内容，常用于写完一些数据后，立即用该函数清除缓冲区，以免误操作时，破坏原来的数据。 flushall()将清除所有打开文件所对应的文件缓冲区。
 
(2).设置文件缓冲区函数
 
 void setbuf(FILE *stream,char *buf); 
 
void setvbuf(FILE *stream,char *buf,int type,unsigned size); 
 
这两个函数将使得打开文件后，用户可建立自己的文件缓冲区，而不使用fopen()函数打开文件设定的默认缓冲区。 对于setbuf()函数，buf指出的缓冲区长度由头文件stdio.h中定义的宏BUFSIZE的值决定，缺省值为512字节。当选定buf为空时，setbuf函数将使的文件I/O不带缓冲。而对setvbuf函数，则由malloc函数来分配缓冲区。参数size指明了缓冲区的长度(必须大于0),而参数type则表示了缓冲的类型，其值可以取如下值： type 值 含义 _IOFBF 文件全部缓冲，即缓冲区装满后，才能对文件读写 _IOLBF 文件行缓冲，即缓冲区接收到一个换行符时，才能对文件读写 _IONBF 文件不缓冲，此时忽略buf,size的值，直接读写文件，不再经过文件缓冲区缓冲。
 
5.文件的随机读写函数
 
 前面介绍的文件的字符/字符串读写，均是进行文件的顺序读写，即总是从文件的开头开始进行读写。这显然不能满足我们的要求，C语言提供了移动文件指针和随机读写的函数，它们是：
 
(1).移动文件指针函数：
 
 long ftell(FILE *stream);
 
 int rewind(FILE *stream);
 
 fseek(FILE *stream,long offset,int origin);
 
 函数ftell()用来得到文件指针离文件开头的偏移量。当返回值是-1时表示出错。 rewind()函数用于文件指针移到文件的开头，当移动成功时，返回0，否则返回一个非0值。 fseek()函数用于把文件指针以origin为起点移动offset个字节，其中origin指出的位置可有以下几种：
 
 origin 数值 代表的具体位置 
 
SEEK_SET 0 文件开头
 
 SEEK_CUR 1 文件指针当前位置
 
 SEEK_END 2 文件尾 
 
例如： fseek(fp,10L,0); 把文件指针从文件开头移到第10字节处，由于offset参数要求是长整型数，故其数后带L。
 
 fseek(fp,-15L,2); 把文件指针从文件尾向前移动15字节。
 
(2).文件随机读写函数
 
 int fread(void *ptr,int size,int nitems,FILE *stream);
 
 int fwrite(void *ptr,int size,int nitems,FILE *stream);
 
 fread()函数从流指针指定的文件中读取nitems个数据项，每个数据项的长度为size个字节，读取的nitems数据项存入由ptr指针指向的内存缓冲区中，在执行fread()函数时，文件指针随着读取的字节数而向后移动，最后移动结束的位置等于实际读出的字节数。该函数执行结束后，将返回实际读出的数据项数，这个数据项数不一定等于设置的nitems，因为若文件中没有足够的数据项，或读中间出错，都会导致返回的数据项数少于设置的nitems。当返回数不等于nitems时，可以用feof()或ferror()函数进行检查。 fwrite()函数从ptr指向的缓冲区中取出长度为size字节的nitems个数据项，写入到流指针stream指向的文件中，执行该操作后，文件指针将向后移动，移动的字节数等于写入文件的字节数目。该函数操作完成后，也将返回写入的数据项数。
 
二、非标准文件的读写
 
 这类函数最早用于UNIX操作系统,ANSI标准未定义,但有时也经常用到,DOS 3.0以上版本支持这些函数。它们的头文件为io.h。 由于我们不常用这些函数，所以在这里就简单说一下。
 
1.文件的打开和关闭
 
 open()函数的作用是打开文件,其调用格式为: int open(char *filename, int access); 该函数表示按access的要求打开名为filename的文件,返回值为文件描述字,其中access有两部分内容: 基本模式和修饰符, 两者用" "("或")方式连接。修饰符可以有多个, 但基本模式只能有一个。 access的规定 -------------------------------------------------------- 基本模式 含义 修饰符 含 义 -------------------------------------------------------- O_RDONLY 只读 O_APPEND 文件指针指向末尾 O_WRONLY 只写 O_CREAT 文件不存在时创建文件, 属性按基本模式属性 O_RDWR 读写 O_TRUNC 若文件存在, 将其长度缩为0, 属性不变 O_BINARY 打开一个二进制文件 O_TEXT 打开一个文字文件 --------------------------------------------------------- open()函数打开成功, 返回值就是文件描述字的值(非负值), 否则返回-1。 close()函数的作用是关闭由open()函数打开的文件, 其调用格式为: int close(int handle); 该函数关闭文件描述字handle相连的文件。
 
2.读写函数
 
 int read(int handle, void *buf, int count);
 
 read()函数从handle(文件描述字)相连的文件中, 读取count个字节放到buf所指的缓冲区中, 返回值为实际所读字节数, 返回-1表示出错。返回0 表示文件结束。 write()函数的调用格式为: int write(int handle, void *buf, int count); write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中, 返回值为实际写入的字节数。
 
3.随机定位函数
 
 lseek()函数的调用格式为: int lseek(int handle, long offset, int fromwhere); 
 
该函数对与handle相连的文件位置指针进行定位,功能和用法与fseek()函数相同。 tell()函数的调用格式为: long tell(int handle); 该函数返回与handle相连的文件现生位置指针, 功能和用法与ftell()相同
 
5. read 函数和 write 函数
 
来源：蚂蚁的 C/C++ 标准编程 作者：antigloss
 
1. read 
 
#include ssize_t read(int filedes, void *buf, size_t nbytes); 返回值：读取到的字节数；0（读到 EOF）；-1（出错） read 函数从 filedes 指定的已打开文件中读取 nbytes 字节到 buf 中。以下几种情况会导致读取到的字节数小于 nbytes ：
 
A. 读取普通文件时，读到文件末尾还不够 nbytes 字节。例如：如果文件只有 30 字节，而我们想读取 100 字节，那么实际读到的只有 30 字节，read 函数返回 30 。此时再使用 read 函数作用于这个文件会导致 read 返回 0 。
 
B. 从终端设备（terminal device）读取时，一般情况下每次只能读取一行。
 
C. 从网络读取时，网络缓存可能导致读取的字节数小于 nbytes 字节。
 
D. 读取 pipe 或者 FIFO 时，pipe 或 FIFO 里的字节数可能小于 nbytes 。
 
E. 从面向记录（record-oriented）的设备读取时，某些面向记录的设备（如磁带）每次最多只能返回一个记录。 F. 在读取了部分数据时被信号中断。读操作始于 cfo 。在成功返回之前，cfo 增加，增量为实际读取到的字节数。
 
2. write
 
 #include ssize_t write(int filedes, const void *buf, size_t nbytes); 返回值：写入文件的字节数（成功）；-1（出错）write 函数向 filedes 中写入 nbytes 字节数据，数据来源为 buf 。返回值一般总是等于 nbytes，否则就是出错了。常见的出错原因是磁盘空间满了或者超过了文件大小限制。 对于普通文件，写操作始于 cfo 。如果打开文件时使用了 O_APPEND，则每次写操作都将数据写入文件末尾。成功写入后，cfo 增加，增量为实际写入的字节数。