C语言4——文件操作

1、文件操作

int main(){
    FILE *p=fopen("D:\\temp\\a.txt","w");//用写的方式打开一个文件
    //w的意思是如果文件不存在就建立一个，如果文件存在就覆盖
    fputs("hello world",p);//向文件中写入一个字符串
    fclose(p);//关闭文件
}

int main(void){
    char s[1024]={0};
    FILE *p=fopen("D:\\temp\\a.txt");
    while(1){
        memset(s,0,sizeof(s));
        gets(s);//gets可以接收空格 而scanf("%s",s);不可以
        if(strcmp(s,"exit")==0){
            break;
        }
        int len=strlen(s);
        s[len]=‘\n‘;//由于我们并不能将scanf中输入的换行显示在文本当中 所以要在每次输入完成字符串之后 按照每次输入的内容换行
        fputs(s,p);
    }
    fclose(p);
    printf("end\n");
    return 0;
}

2、读文件

int main(){
    char s[1024]={0};
    FILE *p=fopen("D:\\temp\\a.txt","r");
    //feof(p);如果已经到了文件结尾，feof函数返回真
    while(!feof(p))//如果没有到文件结尾就一直循环
    {
        memset(s,0,sizeof(s));
        fgets(s,sizeof(s),p);//参数分别是内存地址 这块内存大小 fopen返回的文件指针
        printf("%s",s);
    }
    fclose(p);
    return 0;
}

3、文本文件加密

void code(char *s){
    while(*s){
        (*s)++;
        s++;
    }
}
void decode(char *s){
    while(*s){
        (*s)--;
        s++;
    }
}
int main(){
    char s[1024]={0};
    FILE *p=fopen("D:\\temp\\a.txt","r");
    FILE *p1=fopen("D:\\temp\\b.txt","w");
    while(!feof(p))//如果没有到文件结尾就一直循环
    {
        memset(s,0,sizeof(s));
        fgets(s,sizeof(s),p);
        code(s);
        fputs(s,p1);
    }
    fclose(p);
    fclose(p1);
    return 0;
}

4、读写方式

r 以只读方式打开文件，该文件必须存在
r+ 以可读写方式打开文件，该文件必须存在
rb+ 读写打开一个二进制文件，允许读写数据，文件必须存在
rw+ 读写打开一个文本文件，允许读和写
w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失，若文件不存在则建立该文件
w+ 打开可读写文件，若文件存在则文件长度清为0，即该文件内容会消失，若文件不存在则建立该文件
a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留(EOF符保留)
a+ 以附加的方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留(EOF符保留)

5、fopen

FILE *p=fopen("D:\\temp\\aaaa.txt","r");//如果文件打开，fopen返回打开的文件的指针，如果失败返回NULL
//FILE *p=fopen("D:\\temp\\aaaa.txt","a"); 用追加的方式打开文件，如果文件不存在，就创建这个文件，如果文件存在，就在文件结尾追加
if(p==NULL){
    printf("open fail\n");
}else{
    printf("open success\n");
}
printf("end\n");

int main(){
    FILE *p=fopen("D:\\temp\\aaaa.txt","w");
    if(p==NULL){
        printf("file open fail\n");
    }else{
        fputs("hello\n",p);
        fputs("world\n",p);
        fclose(p);
    }
    printf("end\n");
    return 0;
}
这个程序执行完成之后以16进制方式打开文件，看到
68 65 6C 6C 6F 0D 0A 77 6F 72 6C 64 0D 0A
分别对应
h  e  l  l  o  \r \n w  o  r  l  d  \r \n

int main(){
    FILE *p=fopen("D:\\temp\\aaaa.txt","wb");//如果这里加了b 则按照二进制的方式来读取文件，反之按照文本文件方式来读文件，在Windows系统中，文本模式下，文件以\r\n代表换行，若以文本模式打开文件，并用fputs等函数写入换行符"\n"时，函数会自动在"\n"前面加上"\r" 即实际写入文件的是"\r\n"，而如果按照二进制方式读文件，只会读取到\n，不会读取到\r
    //在类Unix/Linux系统中文本模式下，文件以"\n"代表换行，所以Linux系统中在文本模式和二进制模式下并无区别，在Unix/Linux下w和wb是一样的
    if(p==NULL){
        printf("file open fail\n");
    }else{
        fputs("hello\n",p);
        fputs("world\n",p);
        fclose(p);
    }
    printf("end\n");
    return 0;
}
这个程序执行完成之后以16进制方式打开文件，看到
68 65 6C 6C 6F 0A 77 6F 72 6C 64 0A
分别对应
h  e  l  l  o  \n w  o  r  l  d  \n

6、getc putc

int main(){
    FILE *p=fopen("D:\\text\\a.txt","r");
    if(p==NULL){
        printf("error\n");
    }else{
        char c=0;
        //while(c!=EOF){
        //    c=getc(p);
        //    printf("%c\n",c);
        //}
        //上面while的简化写法如下
        while((c=getc(p)) != EOF){
            printf("%c",c);
        }
        fclose(p);
    }
    printf("Hello world!\n");
    return 0;
}

int main(){//写一个字符
    FILE *p=fopen("D:\\text\\a.txt","w");
    if(p==NULL){
        printf("error\n");
    }else{
        char c=0;
        putc(‘a‘,p);
        fclose(p);
    }
    printf("Hello world!\n");
    return 0;
}

7、EOF和feof

通过fgets读文件的时候通常用feof(p)判断是否到了结尾
通过getc读文件的时候通常用(c=getc(p)) != EOF判断是否到了结尾

8、文本文件排序

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void swap(int *a,int *b){
    int tmp=*a;
    *a=*b;
    *b=tmp;
}
void pupple(int *p,int n){
    int i;
    int j;
    for(i=0;i<n;i++){
        for(j=1;j<n-i;j++){
            if(p[j-1]>p[j]){
                swap(&p[j-1],&p[j]);
            }
        }
    }
}
int main(void){
    int index;
    int array[10]={0};
    char buf[100];
    FILE *p=fopen("D:\\tmp\\a.txt",r);
    if(p==NULL){
        printf("error\n");
    }else{
        while(!feof(p)){
            memset(buf,0,sizeof(buf));//每次读取文件一行之前都把这个buffer清空
            fgets(buf,sizeof(buf),p);//从文件中读一行
            index++;
            array[index]=atoi(buf);
            fclose(p);
        }
    }
    pupple(array,index);
    p=fopen("D:\\tmp\\a.txt","w");//用写的方式打开b.txt
    int i;
    for(i=0;i<index;i++){
        memset(buf,0,sizeof(buf));//操作buf之前先将它清空
        sprintf(buf,"%d\n",array[i]);//将数组的成员转化为字符串
        fputs(buf,p);
    }
    fclose();
    return 0;
}

动态数组解决上面的问题

int main(){
    int index=0;
    char buf[100];
    FILE *p=fopen("D:\\tmp\\a.txt","r");
    while(!feof(p)){
        memset(buf,0,sizeof(buf));
        fgets(buf,sizeof(buf),p);
        index++;
    }
    fclose(p);
    int *array=calloc(sizeof(int),index);
    p=fopen("D:\\tmp\\a.txt","r");
    index=0;
    while(!feof(p)){
        memset(buf,0,sizeof(buf));
        fgets(buf,sizeof(buf),p);
        array[index]=atoi(buf);
        index++;
    }
    fclose(p);
    pupple(array,index);
    p=fopen("D:\\tmp\\b.txt","w");
    int i;
    for(i=0;i<index;i++){
        memset(buf,0,sizeof(buf));
        sprintf(buf,"%d\n",array[i]);
        fputs(buf,p);
    }
    fclose();
    return 0;
}

9、解析文件中的加减乘除

#include<stdio.h>
#include<string.h>
int calc_str(const char *s){
    char buf1[100]={0};
    char oper;
    char buf2[100]={0};
    int len=strlen(s);
    int i;
    for(i=0;i<len;i++){
        if(s[i]==‘+‘ || s[i]==‘-‘ || s[i]==‘*‘ || s[i]==‘/‘){
            strncpy(buf1,s,i);
            oper1=s[i];
            break;
        }
    }
    int start=i+1;
    for(;i<len;i++){
        if(s[i]==‘=‘){
            strncpy(buf2,&s[start],i-start);
        }
    }
    //printf("buf1=%s,oper1=%c,buf2=%s\n",buf1,oper1,buf2);
    switch(oper1){
        case ‘+‘:
            return atoi(buf1)+atoi(buf2);
        case ‘-‘:
            return atoi(buf1)-atoi(buf2);
        case ‘*‘:
            return atoi(buf1)*atoi(buf2);
        case ‘/‘:
            int a=atoi(buf2);
            if(a){
                return atoi(buf1)/atoi(buf2);
            }else{
                return 0;
            }
    }
}
void curReturn(char *s){
    int len=strlen(s);
    if(s[len-1]==‘\n‘){
        s[len-1]=0;
    }
}
int main(){
    FILE *p=fopen("D:\\tmp\\a.txt","r");
    FILE *p1=fopen("D:\\tmp\\b.txt","w");
    char buf[1024];
    char buf1[1024];
    while(!feof(p)){
        memset(buf,0,sizeof(buf));
        fgets(buf,sizeof(buf),p);//从文件中读取一行记录，字符串最后是以‘\n‘结尾的
        cutReturn(buf);
        int value=calc_str(buf);
        memset(buf1,0,sizeof(buf1));
        sprintf(buf1,"%s%d\n",buf,value);
        printf("buf1=%s",buf1);
        fputs(buf1,p1);
    }
    fclose(p);
    fclose(p1);
    return 0;
}

10、fscanf

int main(){
    FILE *p=fopen("D:\\temp\\a.txt","r");
    while(!feof(p)){
        char buf[100]={0};
        //fgets(buf,sizeof(buf),p);
        fscanf(p,"%s",buf);//fscanf与scanf用法基本一致，fscanf是从一个文件读取输入，scanf是从键盘读取输入
        printf("%s",buf);
    }
    fclose(p);
    return 0;
}
int main(){
    FILE *p=fopen("D:\\temp\\a.txt","r");
    while(!feof(p)){
        char buf[100]={0};
        int a=0;
        int b=0;
        fscanf(p,"%d + %d =",&a,&b);//文件中内容必须是固定格式为xx + xx =的形式
        printf("%d %d",a,b);
    }
}

11、printf

int main(){
    FILE *p=fopen("D:\\temp\\a.txt","r");
    char buf[100]="hello world";
    fprintf(p,"%s",buf);//和printf类似，printf输出到屏幕上，fpritnf输出到文件里面
    int a=6;
    int b=7;
    fclose(p);
    return 0;
}

12、fread

int main(){
    FILE *p=fopen("D:\\tmp\\a.txt","rb");//rb代表用读二进制的方式打开一个文件
    char buf[1024]={0};
    fread(buf,sizeof(char),1,p)//第一个参数是缓冲区(存放读取的内容)，第二个参数是读取的基本单元的大小
    //第三个参数是一次读取几个基本单元，第四个参数是打开的文件指针
    printf("buf=%s\n",buf);
    fclose(p);
    return 0;
}

int main(){
    FILE *p=fopen("D:\\tmp\\a.txt","rb");
    while(!feof(p)){
        char buf[10]={0};
        fread(buf,sizeof(char),sizeof(buf),p)
        printf("buf=%s\n",buf);//由于文件中每行都是以\r\n结尾的，一个字节一个字节往出读的话就会把\r\n也读到屏幕上，就会显示出非法的字符
    }
    fclose(p);
    return 0;
}

int main(){
    FILE *p=fopen("D:\\tmp\\a.txt","rb");
    while(!feof(p)){
        char buf[10]={0};
        fread(buf,sizeof(char),sizeof(buf)-1,p)//第三个参数设置为buf的长度减1是为了保证buf是一个合法的字符串(有结尾符)，在下面的printf中就可以直接将读取到的字符串输出了，而且输出的过程中会根据buf最后一个0自动换行
        printf("%s",buf);
    }
    fclose(p);
    return 0;
}

int main(){
    FILE *p=fopen("D:\\tmp\\a.txt");;
    char buf[1024]={0};
    //fread返回值代表读取了多少记录数
    size_t rec=fread(buf,sizeof(char),sizeof(buf),p);//size_t是无符号整型
    printf("%u",res);//如果文件中有3个字符，返回3，有4个字符，返回4，返回的是sizeof(int)的个数
    fclose(p);
}

int main(){
    //假设a.txt中的内容是
    //ab
    //cd
    //以rb 即二进制方式读文件a.txt时，输出的是61 62 a d 63 64，其中a是\n，d是\r
    //以r  即文本文件方式读文件a.txt时，输出的是61 62 a 63 64
    //Windows下如果读取二进制文件必须要加上b，不能只写r
    FILE *p=fopen("D:\\tmp\\a.txt","rb");
    while(!feof(p)){
        char buf[1024]={0};
        int res=fread(buf,sizeof(char),sizeof(buf),p);
        int i;
        for(i=0;i<res;i++){
            printf("%x ",buf[i]);
        }
    }
    fclose(p);
    return 0;
}

13、fwrite

int main(){
    FILE *p=fopen("D:\\tmp\\a.dat","wb");
    char buf[1024]={0};
    buf[0]=‘a‘;
    buf[1]=‘b‘;
    fwrite(buf,sizeof(char),2,p);
    fclose(p);
}

14、二进制文件拷贝

#include<stdlib.h>
#include<string.h>
int main(){
    FILE *p=fopen("D:\\tmp\\a.wmv","rb");
    FILE *p1=fopen("D:\\tmp\\b.wmv","wb");
    char buf[1024 * 4];//每次读4K
    while(!feof(p)){
        memset(buf,0,sizeof(buf));
        size_t res = fread(buf,sizeof(char),sizeof(buf),p);//返回从源文件中读取的字节数
        fwrite(buf,sizeof(char),res,p1);//从源文件中读取多少字节，就往目标文件写多少字节
        //这里一定不能写成fwrite(buf,sizeof(char),sizeof(buf),p1);因为sizeof(buf)是大于等于res的，很有可能拷贝进去多余的字符，如果是拷贝二进制文件，很有可能导致二进制文件打不开
    }
    fclose(p);
    fclose(p1);
    return 0;
}

15、二进制文件的加密

#include<stdlib.h>
#include<string.h>
void code(char *p,size_t n){
    size_t i;
    for(i=0;i<n;i++){
        p[i]+=3;
    }
}
void decode(char *p,size_t n){
    size_t i;
    for(i=0;i<n;i++){
        p[i]-=3;
    }
}
int main(){
    FILE *p=fopen("D:\\tmp\\a.wmv","rb");
    FILE *p1=fopen("D:\\tmp\\b.wmv","wb");
    char buf[1024 * 4];//每次读4K
    while(!feof(p)){
        memset(buf,0,sizeof(buf));
        size_t res = fread(buf,sizeof(char),sizeof(buf),p);
        code(buf,res);
        fwrite(buf,sizeof(char),res,p1);
    }
    fclose(p);
    fclose(p1);
    return 0;
}

16、stat函数

用stat读取文件比上面的方式效率要高很多

#include<stdlib.h>
#include<string.h>
#include<sys/stat.h>
int main(){
    clock_t c1=clock();//时间戳
    struct stat st={0};
    stat("D:\\tmp\\a.txt",&st);//调用完stat函数之后，文件相关的信息就保存在stat中了
    //printf("%u\n",st.st_size);得到文件大小
    char *arr=malloc(st.st_size);//根据文件大小在堆中动态分配内存
    FILE *p=fopen("D:\\tmp\\a.txt","rb");
    fread(arr,sizeof(char),st.st_size,p);//一下把整个文件放入内存
    fclose(p);
    p=fopen("D:\\tmp\\b.wmv","wb");
    fwrite(array,sizeof(char),st.st_size,p);//将堆中的信息一下都写入文件
    fclose(p);
    clock_t c2=clock();//时间戳
    printf("%u",c2-c1);
    return 0;
}

17、结构体与二进制文件

struct student{
    char a;
    int age;
};
int main(){
    struct student st={‘a‘,25};
    FILE *p=fopen("D:\\tmp\\a.dat","wb");//a.dat里面内容是61 00 00 00 1E 00 00 00
    fwrite(&st,sizeof(st),1,p);
    fclose(p);
}

18、读取大文件

#include<time.h>
int main(){
    srand(time(NULL));
    int i;
    FILE *p=fopen("D:\\tmp\\a.txt","w");
    for(i=0;i<1000000000;i++){
        fprintf(p,"%d\n",rand() % 256);
    }
    fclose(p);
    printf("end");
    return 0;
}
//生成的a.txt会很大，大到打开a.txt时都加载不出来，几十兆就打不开了
//如果我们需要对a.txt中的数字进行排序，如果不操作堆内存的话要怎么做呢？
//先考虑小文件的情况
int main(){
    FILE *p=fopen("D:\\tmp\\a.txt","r");
    int array[256]={0};
    while(!feof(p)){
        char buf[100]={0};
        fgets(buf,sizeof(buf),p);//得到一行
        if(buf[0]!=0){//有时候我们会发现b.txt里面第一行是0，但是a.txt文件里面没有哪一行有0，那么证明a.txt文件里面的最后一行是空行
            int value=atoi(buf);//将得到的行转化为整数
            array[value]++;
        }
    }
    fclose(p);
    p=fopen("D:\\temp\\b.txt","w");
    int i;
    int j;
    for(i=0;i<513;i++){
        for(j=0;j<array[i];j++){
            fprintf(p,"%d\n",i);
        }
    }
    fclose(p);
    printf("end");
    return 0;
}

19、fseek

struct student{
    char name[10];
    int age;
};
int main01(){
    struct student st[10]={0};
    int i;
    for(i=0;i<10;i++){
        scanf("%s",st[i].name);
        scanf("%d",&st[i].age);
    }
    FILE *p=fopen("D:\\txt\\a.dat","wb");
    fwrite(st,sizeof(struct student),10,p);
    return 0;
}
int main(){
    struct student st={0};
    FILE *p=fopen("D:\\txt\\a.dat","rb");

    //读取第一个结构体
    memset(&st,0,sizeof(struct student));
    fread(&st,sizeof(struct student),1,p);
    printf("name=%s,age=%d\n",st.name,st.age);

    //读取第二个结构体
    memset(&st,0,sizeof(struct student));
    fread(&st,sizeof(struct student),1,p);
    printf("name=%s,age=%d\n",st.name,st.age);

    //读取第三个结构体
    memset(&st,0,sizeof(struct student));
    fread(&st,sizeof(struct student),1,p);
    printf("name=%s,age=%d\n",st.name,st.age);
    //目前文件指针p在第4个结构，如果在这时想回去的话，可以通过fseek实现
    //或者希望从中间开始读文件，或者倒着往回读，都可以用fseek实现
    fseek(p,sizeof(struct student),SEEK_SET);//SEEK_SET是一个宏，代表文件的开始位置，第二个参数意思是在第三个参数的基础上向后偏移sizeof(struct student)个字节读取
    //第二个参数可以是负值
    //除了SEEK_SET之外，还有SEEK_CUR(当前位置)，SEEK_END(文件结尾位置)
}