读和写流

转自  http://blog.csdn.net/todd911/article/details/12884735

一旦打开了流,则可以对流进行读写:每次一个字符,每次一行,二进制。

1.每次一个字符

使用下面三个函数用于一次读一个字符。
#include <stdio.h>  
int getc(FILE* fp);  
int fgetc(FILE* fp);  
int getchar(void);  
如果成功返回读取到的字符,出错或者到达文件结尾则返回EOF(一般为-1)。getc为宏,fgetc为函数,getchar等价于fgetc(stdin)。
注意:不管是出错还是达到文件结尾,三个函数都返回相同的值,为了区分这2中情况,必须调用ferror或者feof函数。
#include <stdio.h>  
int ferror(FILE* fp);  
int feof(FILE* fp);  
如果条件为真则返回非0值(真),否则返回0(假)。
在大多数实现中,为每个流在FILE结构体中维持了2个标志:
  • 出错标志
  • 文件结束标志
调用clearerr函数则清除这两个标志。
#include <stdio.h>  
void clearerr(FILE* fp);  
实践:
#include <stdio.h>    
int main(void){  
        int c;  
        while((c = fgetc(stdin)) != EOF){  
                fputc(c,stdout);  
        }  
        if(ferror(stdin) > 0){  
                printf("stdin error.\n");  
        }else if(feof(stdin) > 0){  
                printf("stdin eof.\n");  
        }  
  
        clearerr(stdin);  
  
        if(ferror(stdin) > 0){  
                printf("stdin error after clear.\n");  
        }else if(feof(stdin) > 0){  
                printf("stdin eof after clear.\n");  
        }  
        return 0;  
}  
运行结果:
$ ./a.out
12345
12345   ctrl+D
stdin eof.
 
从流中读取数据以后,可以调用ungetc将字符再压送回流中。
#include <stdio.h>  
int ungetc(int c, FILE* fp);  
压送回流中的字符以后又可以从流中读出,但是读出字符的顺序与压送回的顺序相反。回送的字符不必一定是上一次读取的字符,不能回送EOF,但是已经到达文件尾端时,仍可以回送一字符。下次读将返回该字符,再次读则返回EOF。该函数使用的场合是:当正在读一个输入流,并进行某种形式的分字或分记号操作,会经常用到回送字符操作。有时需要先看一下下一个字符,以决定如何处理当前字符。然后就需要方便地将当看完的字符送回,以便下一次调用getc时返回该字符。如果标准IO库不提供回送能力,就需要将该字符存放在一个我们自己的变量中,并设置一个标准以便判断在下一次需要一个字符时是调用getc还是从我们自己的变量中取用。
实践:
#include <stdio.h>  
  
int main(void){  
        int c;  
        if((c = fgetc(stdin)) != EOF){  
                fputc(c,stdout);  
        }  
        ungetc(c,stdin);  
        ungetc(c+1,stdin);  
        while((c = fgetc(stdin)) != EOF){  
                fputc(c,stdout);  
        }  
        printf("\n");  
        return 0;  
}  
运行结果:
$ ./a.out
a
aba 
对应于上面所述的每个输入函数都有一个输出函数对应。
#include <stdio.h>  
int putc(int c, FILE* fp);  
int fputc(int c, FILE* fp);  
int putchar(int c);  
与输入函数一样,putc为宏,fputc为函数,putchar等价于fputc(stdout)。
 
2.每次一行IO
下面两个函数提供每次输入一行的功能。
#include <stdio.h>  
char* fgets(char* restrict buf, int n, FILE* restrict fp);  
char* gets(char * buf);  
如果成功 返回buf,如果出错或者文件已经到达结尾则返回NULL。
对于fgets必须指定缓冲区的长度n,此函数一直读到下一个换行符为止(换行符也被送入到缓冲区),但是不超过n-1个字符,读入的字符被送入缓冲区,该缓冲区以NULL字符结尾。如果该行的字符数(包括最后一个换行符)超过n-1,则fgets只返回一个不完整的行,但是缓冲区总是以NULL字符结尾,对fgets的下一次调用会继续读该行。
gets是一个不推荐的函数。因为没有指定缓冲区的长度,这样就很可能造成缓冲区溢出。gets与fgets的另一个区别是,gets并不将换行符存入缓冲区。 
fputs和puts提供每次输出一行的功能。
#include <stdio.h>  
int fputs(const char* restrict str, FILE* restrict fp);  
int puts(const char* str);  
如果成功 则返回非负值,出错则返回EOF。
函数fputs将一个以NULL符终止的字符串写到指定的流,尾端的终止符NULL不写出。注意,这并不一定是每次输出一行,因为它并不要求在NULL符之前一定是换行符。puts将一个以NULL符终止的字符串写到标准输出,终止符不写出。但是,puts然后又将一个换行符写到标准输出。puts并不像gets那样不安全,但是我们还是应该避免使用它,因为puts会自己加上一个换行符,而如果我们使用fgets和fputs,我们需要自己处理换行符。
实践:
#include <stdio.h>  
  
int main(void){  
        int result = 0;  
        char buf[256];  
        FILE* fp;  
        if((fp = fopen("a.txt", "r+")) == NULL){  
                result = -1;  
                perror("fopen");  
                goto FINALLY;  
        }    
        while(fgets(buf,256,fp) != NULL){  
                fputs(buf,stdout);  
        }  
  
FINALLY:  
        if(fp != NULL){  
                fclose(fp);  
        }  
        return result;  
}  
运行结果:
$ cat a.txt
123
456
$ ./a.out
123
456
$
 
如果将上面的
fputs(buf)
修改成
puts(buf)
则结果为:
$ ./a.out
123

456

$
 
3.二进制IO
下面2个函数执行二进制IO操作。
#include <stdio.h>  
size_t fread(void* restrict ptr, size_t size, size_t nobj, FILE* restrict fp);  
size_t fwrite(const void* restrict ptr, size_t size, size_t nobj, FILE* restrict fp);  
函数返回读或者写的对象数,其中size为每个元素的长度,nobj为欲写入元素的数量。
和getc函数一样,不管是出错还是达到文件结尾,函数都返回相同的值EOF,为了区分这2中情况,必须调用ferror或者feof函数。
函数常见的用法如下:
1.读写一个二进制数组。
#include <stdio.h>  
  
int main(void){  
        int result = 0;  
        int data[10] = {0,1,2,3,4,5,6,7,8,9};  
        int data2[10] = {0};  
        FILE* fp;  
  
        if((fp = fopen("bfile","wb+")) == NULL){  
                result = -1;  
                perror("fopen");  
                goto FINALLY;  
        }  
  
        if(fwrite(&data[1], sizeof(int), 3, fp) < 0){  //写到文件
                result = -1;  
                perror("fwrite");  
                goto FINALLY;  
        }  
  
        fclose(fp);  
  
        if((fp = fopen("bfile","rb+")) == NULL){ 
                result = -1;  
                perror("fopen");  
                goto FINALLY;  
        }  
  
        if(fread(data2, sizeof(int), 3, fp) < 0){   //从文件中读取 ,然后写到data2
                result = -1;  
                perror("fread");  
                goto FINALLY;  
        }  
  
        int i;  
        for(i=0;i<10;i++){  
                printf("i=%d:%d\n",i,data2[i]);  
        }  
  
FINALLY:  
        if(fp != NULL){  
                fclose(fp);  
        }  
        return result;  
}  
运行结果:
$ ./a.out
i=0:1
i=1:2
i=2:3
i=3:0
i=4:0
i=5:0
i=6:0
i=7:0
i=8:0
i=9:0
注意:不是将1写3遍,而是顺序写1,2,3. 
2.读写一个结构。
#include <stdio.h>  
  
typedef struct{  
        int a;  
        char b;  
}myst;  
  
int main(void){  
        int result = 0;  
        FILE* fp;  
        myst st1,st2;  
        st1.a = 1;  
        st1.b = 'a';  
  
        if((fp = fopen("bfile","wb+")) == NULL){  
                result = -1;  
                perror("fopen");  
                goto FINALLY;  
        }  
  
        if(fwrite(&st1, sizeof(myst), 1, fp) < 0){  
                result = -1;  
                perror("fwrite");  
                goto FINALLY;  
        }  
  
        fclose(fp);    
  
        if((fp = fopen("bfile","rb+")) == NULL){  
                result = -1;  
                perror("fopen");  
                goto FINALLY;  
        }  
  
        if(fread(&st2, sizeof(myst), 1, fp) < 0){  
                result = -1;  
                perror("fread");  
                goto FINALLY;  
        }  
  
        printf("st2.a=%d\n",st2.a);  
        printf("st2.b=%c\n",st2.b);  
  
FINALLY:  
        if(fp != NULL){  
                fclose(fp);  
        }  
        return result;  
}   
运行结果:
$ ./a.out
st2.a=1
st2.b=a
posted @ 2015-06-24 16:31  neteasefans  阅读(215)  评论(0编辑  收藏  举报