文件操作(1)

最新推荐文章于 2024-02-29 09:07:03 发布

杨林强

最新推荐文章于 2024-02-29 09:07:03 发布

阅读量228

点赞数

分类专栏： c

c 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文件操作
不论操作什么类型的文件，第一步先打开一个文件，第二步，读写文件，第三步关闭文件。

fopen
r 以只读方式打开文件，该文件必须存在。

r+ 以可读写方式打开文件，该文件必须存在。用r+写文件时候，从文件开始位置写入

rb+ 读写打开一个二进制文件，允许读写数据，文件必须存在。

rw+ 读写打开一个文本文件，允许读和写。

w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。

wb
w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。

a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）,如果文件不存在，a的行为和w是一样的

a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。（原来的EOF符不保留）

“b”只对windows有效，对于unix来讲是无效，

二进制和文本模式的区别

在windows系统中，文本模式下，文件以”\r\n”代表换行。若以文本模式打开文件，并用fputs等函数写入换行符”\n”时，函数会自动在”\n”前面加上”\r”。即实际写入文件的是”\r\n” 。
在类Unix/Linux系统中文本模式下，文件以”\n”代表换行。所以Linux系统中在文本模式和二进制模式下并无区别。
对于GBK编码的汉字，一个汉字两个字节，对于utf8来讲一个汉字3个字节，但如果英文字母都是一个字节

fclose

fclose关闭fopen打开的文件

getc和putc函数

int main()
{
    FILE *fp = fopen("a.txt", "r");
    char c;
    while ((c = getc(fp)) != EOF)
    {
        printf("%c", c);
    }
    fclose(fp);
    return 0;
}

int main()
{
    FILE *fp = fopen("a.txt", "w");
    const char *s = "hello world";
    int i;
    for (i = 0; i < strlen(s); i++)
    {
        putc(s[i], fp);
    }
    fclose(fp);
    return 0;
}

EOF与feof函数文件结尾

程序怎么才能知道是否已经到达文件结尾了呢？EOF代表文件结尾
如果已经是文件尾，feof函数返回true。

fprintf,fscanf,fgets,fputs函数

这些函数都是通过FILE *来对文件进行读写。
fscanf不会读取行尾的’\n’,fgets 会将行尾的’\n’读取到buf里面
不论fprintf还是fputs都不会自动向行尾添加\n,需要代码中往buf的行尾写\n才可以达到换行的目录

stat函数

#include <sys/stat.h>
函数的第一个参数代表文件名，第二个参数是struct stat结构。
得到文件的属性，包括文件建立时间，文件大小等信息。

代码示例

// 读文件.
int main()
{
    FILE *p = fopen("a.txt", "r"); 
    // 第一个参数代表文件名
    // 第二个参数代表打开方式
    // 返回值为NULL代表打开失败,否则返回文件流

    if (p == NULL) {
        printf("a.txt open fail\n");
    } else {
        printf("a.txt open success\n")
        char c = 0;
        // 对于文件来说最后一个字符是EOF
        while ((c = getc(p)) != EOF) {
            // printf("c = %c\n", c);
            // printf("%c\n", c);
        }
        printf("\n");
    }

    fclose(p);
    return 0;
}

// 写文件.
int main()
{
    FILE *p = fopen("a.txt", "r");
    FILE *p2 = fopen("b.txt", "w"); 

    if (p == NULL || p2 == NULL) {
        printf("open fail\n");
    } else {
        printf("open success\n")
        char c = 0;
        // 对于文件来说最后一个字符是EOF
        while ((c = getc(p)) != EOF) {
            putc(c, p2);
        }
        printf("\n");
    }

    fclose(p);
    fclose(p2);
    return 0;
}

// 封装文件的加密.
void code(const char *src, const char *dest)
{
    FILE *p = fopen(src, "r");
    FILE *p2 = fopen(dest, "w"); 

    if (p == NULL || p2 == NULL) {
        printf("open fail\n");
    } else {
        printf("open success\n")
        char c = 0;
        // 对于文件来说最后一个字符是EOF
        while ((c = getc(p)) != EOF) {
            c += 10
            putc(c, p2);
        }
        printf("\n");
    }

    fclose(p);
    fclose(p2);
}

// 封装文件的解密.
void decode(const char *src, const char *dest)
{
    FILE *p = fopen(src, "r");
    FILE *p2 = fopen(dest, "w"); 

    if (p == NULL || p2 == NULL) {
        printf("open fail\n");
    } else {
        printf("open success\n")
        char c = 0;
        // 对于文件来说最后一个字符是EOF
        while ((c = getc(p)) != EOF) {
            c -= 10
            putc(c, p2);
        }
        printf("\n");
    }

    fclose(p);
    fclose(p2);
}

int main()
{
    code("a.txt", "b.txt");
    decode("b.txt", "c.txt");
}


int main()
{
    FILE *p1 = fopen("a.txt", "r");
    FILE *p2 = fopen("b.txt", "w"); 

    char buf[1024] = {0};

    // 判断文件是否已经到末尾.
    while (!feof(p1)) {
        // 读取文件一行.
        fgets(buf, sizeof(buf), p1);
        // 写入文件一行.
        fputs(buf, p2);
    }

    fclose(p1);
    fclose(p2);
    return 0;
}

sprintf(buf, "%s%d\n", "hello", 250); // 和printf是一样的,将目标输出到字符串
fprintf(p, "%s", buf) // 将字符串输出到文件.
fscanf(p, "%s", buf) // 读取文件到字符串buf,如果一行中有空格,那么空格之后就读到下一行


// udp文件传递.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h> // 得到文件信息.
#include "myudp.h"

int main(argv, char *args[])
{
    if (argv < 4) {
        printf("参数1是源文件名, 参数2是目标文件名, 参数3执行任务");
        return 0;
    }

    // 进行文件发送.
    if (atoi(args[3]) == 1) {
        FILE *p1 = fopen("./a.txt", "r");

        // 代码优化----start.
        struct stat st;
        memset(&st, 0, sizeof(st));
        stat(argv[1], &st);
        // 根据文件大小申请堆内存.
        char buf = malloc(sizeof(st.st_size);

        while (!feof(p1)) {
            char tmp[1024] = {0};
            memset(tmp, 0, sizeof(tmp));
            // 读取文件信息.
            fgets(tmp, sizeof(tmp), p1);
            strcat(buf, tmp);
        }
        send_socket("127.0.0.1", 8080, buf, sizeof(buf));
        // 发送文件结束标识.
        char c = EOF;
        send_socket("127.0.0.1", 8080, &c, sizeof(c));
        free(buf);
        // 代码优化----end.


        char buf1[1024] = {0};
        while (!feof(p1)) {
            memset(buf1, 0, sizeof(buf1));
            // 读取文件信息.
            fgets(buf1, sizeof(buf1), p1);
            // 发送文件信息.
            send_socket("127.0.0.1", 8080, buf1, sizeof(buf1));
        }
        // 发送文件结束标识.
        char c = EOF;
        send_socket("127.0.0.1", 8080, &c, sizeof(c));
        fclose(p1);

    } else if (atoi(args[3]) == 2) {
        // 文件接收.
        // 绑定端口.
        bind_socket(8080);
        char buf2[1024] = {0};
        char IP[100] = {0};
        while (1) {
            memset(buf2, 0, sizeof(buf2));
            recv_socket(buf2, sizeof(buf2), IP);
            // 判断文件是否传递结束.
            if (buf2[0] == EOF) {
                break;
            }
            printf("%s", buf2);
        }
    }

    return 0;
}