C语言文件操作

fwrite()和fread()

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) 
把 ptr 所指向的数组中的数据写入到给定流 stream 中。
size -- 这是要被写入的每个元素的大小，以字节为单位。
nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
如果成功，该函数返回一个 size_t 对象，表示元素的总数，该对象是一个整型数据类型。

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) 
从给定流 stream 读取数据到 ptr 所指向的数组中。
size -- 这是要读取的每个元素的大小，以字节为单位。
nmemb -- 这是元素的个数，每个元素的大小为 size 字节
成功读取的元素总数会以 size_t 对象返回，size_t 对象是一个整型数据类型。如果总数与 nmemb 参数不同，则可能发生了一个错误或者到达了文件末尾。

char c[] = "This is runoob";
char buffer[20];
fwrite(c, strlen(c) + 1, 1, fp);
fseek(fp, 0, SEEK_SET);
fread(buffer, strlen(c) + 1, 1, fp);
printf("%s\n", buffer);

fprintf() fscanf() rewind()

int fprintf(FILE *stream, const char *format, ...) 
发送格式化输出到流 stream 中。
fprintf(fp, "%s %s %s %d", "We", "are", "in", 2021);

int fscanf(FILE *stream, const char *format, ...) 
从流 stream 读取格式化输入。
fputs("We are in 2014", fp);
rewind(fp);
fscanf(fp, "%s %s %s %d", str1, str2, str3, &year);

void rewind(FILE *stream) 
设置文件位置为给定流 stream 的文件的开头。


fwrite()和fread()对应；
fwrite()写入txt，打开txt是乱码，但是能fread()读取;

fprintf()和fscanf()对应
fprintf()写入txt，打开能正确显示，但是不能用fread()读取。用fscanf()读取，fscanf()返回读取的个数。


写入到文件fp
fprintf(fp, "This is a test");

char s[10];
scanf("%s", s);
fprintf(fp, s);


写入与读取
while (gets(words) != NULL && words[0] != '\0')
	fprintf(fp, "%s ", words);  //写入到fp
	
rewind(fp);//指针指向文件开头
while (fscanf(fp, "%s", words) == 1) //从fp读取
	puts(words);//输出


复制文件
int main(void)
{
    FILE *fin = fopen("1.txt", "rb");
    FILE *fout = fopen("2.txt", "wb");
    char ch;
    while (fscanf(fin, "%c", &ch) == 1)
    {
        printf("%c", ch);
        fprintf(fout, "%c", ch);
    }
    return 0;
}

fseek() ftell()

int fseek(FILE *stream, long int offset, int whence)
设置流 stream 的文件位置为给定的偏移 offset，参数 offset 意味着从给定的 whence 位置查找的字节数。
stream -- 是指向 FILE 对象的指针，该 FILE 对象标识了流。
offset -- 是相对 whence 的偏移量，以字节为单位。
whence -- 是表示开始添加偏移 offset 的位置。指定为下列常量之一：
SEEK_SET	文件的开头
SEEK_CUR	文件指针的当前位置
SEEK_END	文件的末尾

long int ftell(FILE *stream) 
返回给定流 stream 的当前文件位置。

计算文件字节数
fseek(stream, 0L, SEEK_END);
long length = ftell(stream);
length就是文件字节数

fputs("This is a test", fp);
fseek( fp, 7, SEEK_SET ); //fp指向从开始位置偏移的7个字节处
fputs(" C Programming Langauge", fp);
输出：This is C Programming Langauge

feof() fgetc(fp) fputc(ch, fp)

int feof(FILE *stream) 
测试给定流 stream 的文件结束标识符。

int fgetc(FILE *stream) 
从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。
该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF。

int fputc(int char, FILE *stream) 
把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。
如果没有发生错误，则返回被写入的字符。如果发生错误，则返回 EOF，并设置错误标识符。


int main(void)
{
    FILE *fp = fopen("1.txt", "r");
    char ch = fgetc(fp); /*从文件中读取字符*/
    while (!feof(fp))
    {
        if (ch >= 'a' && ch <= 'z')
            ch = ch - 32;
        putchar(ch);
        ch = fgetc(fp);
    }
    return 0;
}

复制文件
int main(void)
{
    FILE *fin = fopen("1.txt", "rb");
    FILE *fout = fopen("2.txt", "wb");
    char ch;
    while (!feof(fin))
    {
        ch = fgetc(fin);  //从fin中读取
        fputc(ch, fout);  //写入到fout
    }
    return 0;
}

getc() putc()

int getc(FILE *stream) 
从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。

int putc(int char, FILE *stream) 
把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。


int main()
{
   char c = getc(stdin);
   putc(c, stdout);
   
   return(0);
}

for (ch = 33; ch <= 100; ch++)
    putc(ch, fp);

fgets() fputs()

char *fgets(char *str, int n, FILE *stream) 
从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

int fputs(const char *str, FILE *stream)
把字符串写入到指定的流 stream 中，但不包括空字符。

fgets() 只读取限定数量的字符。不同于gets(s), gets(s) 大小可能会超出s[] 数组的大小，有风险。
char str[1024];
fgets(str, sizeof(str), fp);


int main(void)
{
    FILE *stream = fopen("1.txt", "w+");
    char string[] = "This is a test";
    char msg[20];
    fwrite(string, strlen(string), 1, stream); //将string写入stream
    fseek(stream, 0, SEEK_SET);                //指针指向开头
    fgets(msg, strlen(string) + 1, stream);    //从stream读取string
    printf("%s", msg);
    return 0;
}

gets() puts()

char *gets(char *str) 
从标准输入 stdin 读取一行，并把它存储在 str 所指向的字符串中。当读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

int puts(const char *str) 
把一个字符串写入到标准输出 stdout，直到空字符，但不包括空字符。换行符会被追加到输出中。

sprintf() rename()

int sprintf(char *str, const char *format, ...) 
发送格式化输出到 str 所指向的字符串。
如果成功，则返回写入的字符总数，不包括字符串追加在字符串末尾的空字符。如果失败，则返回一个负数。

int sscanf(const char *str, const char *format, ...) 
从字符串读取格式化输入。
如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。

int rename(const char *old_filename, const char *new_filename) 
把 old_filename 所指向的文件名改为 new_filename。
如果成功，则返回零。如果错误，则返回 -1，并设置 errno。

更改文件名或者后缀，先将文件夹放在程序所在的文件夹内
int main()
{
    char old[10] = "gif";
    char new[10] = "gif";
    int n = 100;
    for (int i = 1; i < n; i++)
    {
        char oldname[50];
        char newname[50];
        sprintf(oldname, "00/x (%d).%s", i, old);
        sprintf(newname, "00/%d.%s", i, new);
        rename(oldname, newname);
    }
    return 0;
}

从字符串读取格式化输入
int main()
{
    int day, year;
    char weekday[20], month[20], dtm[100];
    strcpy(dtm, "Saturday March 25 1989");

    sscanf(dtm, "%s %s %d  %d", weekday, month, &day, &year);
    printf("%s %d, %d = %s\n", month, day, year, weekday);
    return (0);
}

freopen()

FILE *freopen(const char *filename, const char *mode, FILE *stream) 
把一个新的文件名 filename 与给定的打开的流 stream 关联，同时关闭流中的旧文件。
如果文件成功打开，则函数返回一个指针，指向用于标识流的对象。否则，返回空指针。

在调用 freopen() 之后，它会关联标准输出 STDOUT 到文件 file.txt，无论我们在标准输出 STDOUT 中写了什么都会被写入 file.txt

int main()
{
    FILE *fp = freopen("1.txt", "a+", stdout);
    char s[100];

    printf("该文本重定向到 stdout\n");
    gets(s);
    printf("%s\n", s);
    printf("%s\n", s);
    printf("%s\n", s);
    fclose(fp);
    return (0);
}

void WriteFile(FILE *fp)
{
    char ch;
    printf("请输入文件内容，以#结尾！\n");
    while ((ch = getchar()) != '#')
        fputc(ch, fp);
    rewind(fp);//指针指向文件开头
}
void ReadFile(FILE *fp)
{
    printf("读取文件内容\n");
    char ch = fgetc(fp);
    while (ch != EOF)
    {
        putchar(ch);
        ch = fgetc(fp);
    }
    printf("\n文件读取结束");
}

文件操作-去空格
int main(void)
{
    FILE *fp = fopen("1.txt", "rb");
    fseek(fp, 0L, SEEK_END); //go to end of file
    // if SEEK_END not supported, use this instead
    // last = 0;
    // while (getc(fp) != EOF)
    //     last++;
    long last = ftell(fp);
    for (int count = 0; count <= last; count++)
    {
        fseek(fp, count, SEEK_SET); // go backward
        char ch = getc(fp);
        if (ch == ' ' || ch == '\t' || ch == '\r')
            continue;
        else
            putchar(ch);
    }
    return 0;
}

文件倒序输出
int main(void)
{
    char file[50], ch;
    FILE *fp = fopen(file, "rb");
    puts("Enter the name of the file to be processed:");
    gets(file);

    fseek(fp, 0L, SEEK_END); //go to end of file
    long last = ftell(fp);

    for (long count = last - 1; count >= 0; count--)
    {
        fseek(fp, count, SEEK_SET); // go backward
        ch = getc(fp);
        // for DOS, works with UNIX
        if (ch != '\r')
            putchar(ch);
    }
    fclose(fp);
    return 0;
}

文件加入字符'a'
int main()
{
    FILE *fp = fopen("1.txt", "r+b"); //以二进制读写方式打开文件
    //2.获取文件大小（字节数）
    fseek(fp, 0, SEEK_END); //指针fp指到文件结尾；
    int len = ftell(fp);    //获取文件大小

    fseek(fp, 0, SEEK_SET); //指针fp重新指到文件头；
    //3.每个一个字符插入一个加密字符
    char ch = 'a';
    for (int i = 0; i < len; i++)
    {
        fwrite(&ch, 1, 1, fp);  //写入字符；元素，大小1个字节，个数1个，fp
        fseek(fp, 1, SEEK_CUR); //当前指针fp向后移动1位；
    }
    return 0;
}

从文件中读取结构体(不含头结点的头插法)
struct info *readFromFile()
{
	struct info *head = NULL;
	struct info *node = NULL;
	FILE *fp = fopen("test.txt", "r");

	printf("读取的数目： ");
	int temp = 0;
	scanf("%d", &temp);

	for (int i = 0; i < temp && (!feof(fp)); i++)
	{
		node = solo();
		//fread(node, sizeof(struct info), 1, fp);
		fscanf(fp, "%s%s%d%d%d", node->name, node->no, &node->date.year, &node->date.month, &node->date.day);
		node->next = head;
		head = node;
	}
	fclose(fp);
	return head;
}
输出到文件
void output(struct info *head)
{
	FILE *fp = fopen("test.txt", "a");
	while (head != NULL)
	{
		fprintf(fp, "%s\t%s\t%d\t%d\t%d\n", head->name, head->no, head->date.year, head->date.month, head->date.day);
		//fwrite(head, sizeof(struct info), 1, fp);
		head = head->next;
	}
	fclose(fp);
}

struct address
{
    char name[10];
    char adr[20];
    char tel[15];
} info[100]; 

将一组数据输出到fp所指的文件中
void save(char *name, int n)
{
    FILE *fp = fopen(name, "wb");
    for (int i = 0; i < n; i++)
        fwrite(&info[i], sizeof(struct address), 1, fp);
    fclose(fp);
}
从fp所指向的文件读入数据存到数组score中
void show(char *name, int n)
{
    FILE *fp = fopen(name, "rb");
    for (int i = 0; i < n; i++)
    {
        fread(&info[i], sizeof(struct address), 1, fp);
        printf("%15s%20s%20s\n", info[i].name, info[i].adr, info[i].tel);
    }
    fclose(fp);  
}
int main()
{         
    char filename[50]; 
    printf("请输入文件路径及名称:\n");
    scanf("%s", filename); 
    printf("请输入学生的姓名、地址、电话:\n");
    for (int i = 0; i < 3; i++) 
    {
        scanf("%s%s%s", info[i].name, info[i].adr, info[i].tel);
        save(filename, n); 
    }
    show(filename, n); 
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N 20
#define M 3
struct stu
{
    char name[N];
    int score[M];
    double avg;
};

void swap(struct stu *m, struct stu *n)
{
    stu t = *m;
    *m = *n;
    *n = t;
}
void input(struct stu *s, int n)
{
    double sum = 0;
    for (int i = 0; i < n; i++)
    {
        printf("请输入姓名：");
        scanf("%s", s[i].name);
        printf("请输入分数（英语数C）：");
        for (int j = 0; j < M; j++)
            scanf("%d", &s[i].score[j]);
        printf("\n");
    }
}
void sort(struct stu *s, int n)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        double sum = 0;
        for (j = 0; j < M; j++)
            sum += s[i].score[j];
        s[i].avg = sum / M;
    }
    //排序；平均分相同则比较name；
    for (i = 1; i < n; i++)
        for (j = 0; j < n - i; j++)
            if (s[j].avg < s[j + 1].avg)
                swap(&s[j], &s[j + 1]);
            else if ((s[j].avg == s[j + 1].avg) && (strcmp(s[j].name, s[j + 1].name) < 0))
                swap(&s[j], &s[j + 1]);
}
void save(struct stu *s, int n)
{
    FILE *fp = fopen("test.txt", "w");
    for (int i = 0; i < n; i++)
    {
        //fwrite(&s[i],sizeof(stu),1,fp);
        fprintf(fp, "%s\t", s[i].name);
        for (int j = 0; j < M; j++)
            fprintf(fp, "%d\t", s[i].score[j]);
        fprintf(fp, "%f\n", s[i].avg);
    }
    fclose(fp);
}
void output(struct stu *s, int n)
{
    int i = 0;
    FILE *fp = fopen("test.txt", "r");
    while (!feof(fp))
    {
        //fread(&s[i],sizeof(stu),1,fp);
        fscanf(fp, "%s", s[i].name);
        for (int j = 0; j < M; j++)
            fscanf(fp, "%d", &s[i].score[j]);
        fscanf(fp, "%f", &s[i].avg);
        i++;
    }
    fclose(fp);

    for (i = 0; i < n; i++)
    {
        printf("%s\t", s[i].name);
        for (j = 0; j < M; j++)
            printf("%d   ", s[i].score[j]);
        printf("%.1lf", s[i].avg);
        printf("\n");
    }
}
int main()
{
    int n;
    struct stu s[N];
    printf("input n:");
    scanf("%d", &n);
    
    input(s, n);
    sort(s, n);
    save(s, n);
    output(s, n);
    return 0;
}