1
2
3
4
5

// 文本模式：计算机会帮你处理换行符转换
FILE *text_file = fopen("notes.txt", "w");  // Windows 上写入 \n 会变成 \r\n

// 二进制模式：原封不动，爱写啥写啥
FILE *binary_file = fopen("image.png", "wb");  // 严格的字节对应

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.h>

int main() {
    // 用文本模式写入数字
    FILE *fp = fopen("number.txt", "w");
    fprintf(fp, "%d", 12345);
    fclose(fp);

    // 用二进制模式写入数字
    fp = fopen("number.bin", "wb");
    int num = 12345;
    fwrite(&num, sizeof(num), 1, fp);
    fclose(fp);

    // 查看文件大小：
    // number.txt: 5 个字节（"12345"的文本）
    // number.bin: 4 个字节（int 的二进制表示）

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <stdio.h>

int main() {
    int age;

    // 从 stdin 读取输入
    printf("请输入你的年龄: ");  // 这货是 stdout
    scanf("%d", &age);           // 从 stdin 读取

    if (age < 0) {
        // 错误信息输出到 stderr（立即显示！）
        fprintf(stderr, "错误: 年龄不能是负数！\n");
        return 1;
    }

    printf("你的年龄是 %d 岁\n", age);  // stdout
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 把 stdout 重定向到文件：程序输出写入 output.txt
./my_program > output.txt

# 把 stdin 重定向：程序从文件读取输入
./my_program < input.txt

# 把 stderr 重定向到文件（注意：2 是 stderr 的文件描述符）
./my_program 2> error.txt

# 同时重定向 stdout 和 stderr
./my_program > all_output.txt 2>&1

1
2
3

#include <stdio.h>

FILE *fopen(const char *filename, const char *mode);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>

int main() {
    // ❌ 错误示范：不检查返回值
    FILE *fp = fopen("data.txt", "r");
    fprintf(fp, "Hello");  // 如果文件不存在，fp 是 NULL，程序崩溃！
    fclose(fp);

    // ✅ 正确示范：检查返回值
    FILE *fp2 = fopen("data.txt", "r");
    if (fp2 == NULL) {
        printf("打开文件失败！\n");
        return 1;  // 或者做其他错误处理
    }
    // 现在可以安全地使用 fp2 了
    fclose(fp2);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <stdio.h>

int main() {
    // 写入新文件（不存在则创建）
    FILE *fp = fopen("hello.txt", "w");
    if (fp == NULL) {
        perror("创建文件失败");
        return 1;
    }
    fprintf(fp, "Hello, World!\n");
    fclose(fp);
    printf("文件写入成功！\n");

    // 追加内容
    fp = fopen("hello.txt", "a");
    if (fp == NULL) {
        perror("打开文件失败");
        return 1;
    }
    fprintf(fp, "这是追加的内容。\n");
    fclose(fp);
    printf("内容追加成功！\n");

    // 读取文件
    fp = fopen("hello.txt", "r");
    if (fp == NULL) {
        perror("打开文件失败");
        return 1;
    }
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("%s", buffer);  // fgets 已经包含 '\n'
    }
    fclose(fp);

    return 0;
}

1
2
3
4
5
6

#define __STDC_WANT_LIB_EXT1__ 1  // 必须定义这个才能用
#include <stdio.h>

errno_t fopen_s(FILE * * restrict stream,
                const char * restrict filename,
                const char * restrict mode);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>
#define __STDC_WANT_LIB_EXT1__ 1

int main() {
    FILE *fp;

    // 传统方式：手动检查
    fp = fopen("data.txt", "r");
    if (fp == NULL) {
        perror("fopen 失败");
        return 1;
    }
    fclose(fp);

    // C11 安全方式
    errno_t err = fopen_s(&fp, "data.txt", "r");
    if (err != 0) {
        printf("fopen_s 失败，错误码: %d\n", err);
        // 可以用 strerrorerr_s 获取错误信息
        return 1;
    }
    fclose(fp);

    return 0;
}

1
2
3

#include <stdio.h>

int fclose(FILE *stream);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>

int main() {
    FILE *fp = fopen("important.txt", "w");
    if (fp == NULL) {
        return 1;
    }

    // 写入内容
    fprintf(fp, "这是非常重要的数据！\n");
    fprintf(fp, "如果突然断电，这些数据可能还在缓冲区里...\n");

    // ❌ 错误：忘记关闭文件
    // return 0;  // 数据还在缓冲区，程序一退出就没了！

    // ✅ 正确：先刷新缓冲区，再关闭
    fflush(fp);  // 强制把缓冲区内容写入磁盘
    fclose(fp);  // 关闭文件

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>

int main() {
    FILE *fp1 = fopen("file1.txt", "r");
    FILE *fp2 = fopen("file2.txt", "r");
    FILE *fp3 = fopen("file3.txt", "r");

    // ... 使用文件 ...

    // 正确关闭所有文件
    if (fp1) fclose(fp1);
    if (fp2) fclose(fp2);
    if (fp3) fclose(fp3);

    return 0;
}

1
2
3
4
5
6
7

#include <stdio.h>

// 读取数据
size_t fread(void *ptr, size_t size, size_t count, FILE *stream);

// 写入数据
size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <stdio.h>

int main() {
    // ===== 写入二进制数据 =====
    FILE *fp = fopen("numbers.bin", "wb");
    if (fp == NULL) {
        perror("打开文件失败");
        return 1;
    }

    int nums[] = {100, 200, 300, 400, 500};
    size_t written = fwrite(nums, sizeof(int), 5, fp);
    printf("写入了 %zu 个整数\n", written);  // 输出: 写入了 5 个整数
    fclose(fp);

    // ===== 读取二进制数据 =====
    fp = fopen("numbers.bin", "rb");
    if (fp == NULL) {
        perror("打开文件失败");
        return 1;
    }

    int read_nums[5];
    size_t read_count = fread(read_nums, sizeof(int), 5, fp);
    printf("读取了 %zu 个整数: ", read_count);
    for (int i = 0; i < 5; i++) {
        printf("%d ", read_nums[i]);
    }
    printf("\n");  // 输出: 读取了 5 个整数: 100 200 300 400 500
    fclose(fp);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>
#include <string.h>

typedef struct {
    char name[50];
    int age;
    float gpa;
} Student;

int main() {
    Student s1 = {"张三", 20, 3.85f};
    Student s2;

    // 写入结构体
    FILE *fp = fopen("student.bin", "wb");
    if (fp == NULL) return 1;

    fwrite(&s1, sizeof(Student), 1, fp);
    fclose(fp);

    // 读取结构体
    fp = fopen("student.bin", "rb");
    if (fp == NULL) return 1;

    fread(&s2, sizeof(Student), 1, fp);
    printf("姓名: %s, 年龄: %d, GPA: %.2f\n",
           s2.name, s2.age, s2.gpa);
    // 输出: 姓名: 张三, 年龄: 20, GPA: 3.85
    fclose(fp);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <stdio.h>

int main() {
    FILE *fp = fopen("small.bin", "rb");
    if (fp == NULL) return 1;

    char buffer[100];
    // 尝试读取 100 个字节，但文件可能只有 30 字节
    size_t n = fread(buffer, 1, 100, fp);

    printf("实际读取了 %zu 个字节\n", n);  // n < 100 说明文件没那么大

    // 判断是到了文件尾还是出错了？
    // 需要结合 feof() 和 ferror() 来判断！

    fclose(fp);
    return 0;
}

1
2
3
4

#include <stdio.h>

int fprintf(FILE *stream, const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <stdio.h>

int main() {
    // ===== fprintf: 格式化写入文件 =====
    FILE *fp = fopen("students.txt", "w");
    if (fp == NULL) return 1;

    fprintf(fp, "%s %d %.2f\n", "张三", 20, 3.85);
    fprintf(fp, "%s %d %.2f\n", "李四", 22, 3.92);
    fprintf(fp, "%s %d %.2f\n", "王五", 19, 3.78);
    fclose(fp);

    // ===== fscanf: 格式化读取文件 =====
    fp = fopen("students.txt", "r");
    if (fp == NULL) return 1;

    char name[50];
    int age;
    float gpa;

    printf("=== 学生信息 ===\n");
    while (fscanf(fp, "%s %d %f", name, &age, &gpa) == 3) {
        // fscanf 返回成功匹配的项目数
        printf("%s: 年龄=%d, GPA=%.2f\n", name, age, gpa);
    }
    fclose(fp);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>

int main() {
    FILE *fp = fopen("test.txt", "w");
    fprintf(fp, "Hello World\n");  // 中间有空格
    fclose(fp);

    fp = fopen("test.txt", "r");
    char buffer[100];

    // ❌ 错误：fscanf 遇到空格就停了
    fscanf(fp, "%s", buffer);  // 只读到 "Hello"，"World" 被忽略了
    printf("fscanf: %s\n", buffer);

    // ✅ 正确：使用 fgets 读取整行
    rewind(fp);  // 回到文件开头
    fgets(buffer, sizeof(buffer), fp);
    printf("fgets: %s", buffer);

    fclose(fp);
    return 0;
}

1
2
3

#include <stdio.h>

char *fgets(char *s, int n, FILE *stream);

1
2
3

#include <stdio.h>

int fputs(const char *s, FILE *stream);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <stdio.h>

int main() {
    // ===== 写入多行文本 =====
    FILE *fp = fopen("poem.txt", "w");
    if (fp == NULL) return 1;

    fputs("床前明月光\n", fp);
    fputs("疑是地上霜\n", fp);
    fputs("举头望明月\n", fp);
    fputs("低头思故乡\n", fp);
    fclose(fp);

    // ===== 逐行读取并显示 =====
    fp = fopen("poem.txt", "r");
    if (fp == NULL) return 1;

    char line[100];
    int line_num = 1;

    while (fgets(line, sizeof(line), fp) != NULL) {
        printf("%2d: %s", line_num++, line);
        // fgets 会保留换行符，所以 printf 不需要加 \n
    }

    // 检查是读完了还是出错了
    if (feof(fp)) {
        printf("\n文件读完了。\n");
    } else if (ferror(fp)) {
        printf("\n读取出错！\n");
    }

    fclose(fp);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <stdio.h>

int main() {
    char buffer[10];

    // ❌ 危险：gets 不检查长度，输入超过 9 个字符会溢出
    // gets(buffer);  // C11 已经删除了 gets()

    // ✅ 安全：fgets 限制长度
    fgets(buffer, sizeof(buffer), stdin);
    // 如果输入 "HelloWorld123"，buffer 里只会是 "HelloWorl"
    // （前 9 个字符 + \0）

    printf("你输入了: %s\n", buffer);

    return 0;
}

1
2
3

#include <stdio.h>

int fgetc(FILE *stream);

1
2
3

#include <stdio.h>

int fputc(int c, FILE *stream);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <stdio.h>

int main() {
    // ===== 复制文件（逐字符版） =====
    FILE *src = fopen("source.txt", "r");
    if (src == NULL) {
        perror("打开源文件失败");
        return 1;
    }

    FILE *dst = fopen("dest.txt", "w");
    if (dst == NULL) {
        fclose(src);
        perror("创建目标文件失败");
        return 1;
    }

    int ch;  // 注意：要用 int，不能用 char！
    while ((ch = fgetc(src)) != EOF) {
        fputc(ch, dst);
    }

    // 判断是正常结束还是出错了
    if (feof(src)) {
        printf("文件复制完成！\n");
    } else {
        printf("复制过程中出现错误！\n");
    }

    fclose(dst);
    fclose(src);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>

int main() {
    // 读取一个二进制文件，里面可能有值是 255 的字节
    FILE *fp = fopen("binary.bin", "rb");
    if (fp == NULL) return 1;

    int ch;
    while ((ch = fgetc(fp)) != EOF) {
        // 如果用 char，这里会错过某些合法的字节
        putchar(ch);
    }

    fclose(fp);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <stdio.h>

int main() {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) return 1;

    // 方式一：循环读取，最后判断原因（推荐）
    int ch;
    while ((ch = fgetc(fp)) != EOF) {
        putchar(ch);
    }

    if (feof(fp)) {
        printf("\n正常到达文件末尾。\n");
    } else if (ferror(fp)) {
        printf("\n读取出错！\n");
    }

    // 方式二：用 fread 的返回值判断
    rewind(fp);
    char buffer[100];
    size_t n;
    while ((n = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
        // 处理 buffer[0] 到 buffer[n-1]
        fwrite(buffer, 1, n, stdout);
    }

    if (feof(fp)) {
        printf("\n正常到达文件末尾。\n");
    } else if (ferror(fp)) {
        printf("\n读取出错！\n");
    }

    fclose(fp);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>

int main() {
    FILE *fp = fopen("nonexistent.txt", "r");
    if (fp == NULL) {
        perror("打开文件失败");
        return 1;
    }

    // 先读取试试
    int ch = fgetc(fp);

    if (ch == EOF) {
        if (feof(fp)) {
            printf("文件是空的。\n");
        } else if (ferror(fp)) {
            printf("读取时发生错误！\n");
        }
    } else {
        printf("第一个字符是: %c\n", ch);
    }

    fclose(fp);
    return 0;
}

1
2
3

#include <stdio.h>

long ftell(FILE *stream);

1
2
3

#include <stdio.h>

int fseek(FILE *stream, long offset, int whence);

1
2
3

#include <stdio.h>

void rewind(FILE *stream);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>

int main() {
    FILE *fp = fopen("sample.txt", "w+");
    if (fp == NULL) return 1;

    // 写入数据
    fprintf(fp, "Hello, World!");
    printf("写入后，指针位置: %ld\n", ftell(fp));  // 输出: 13

    // ===== 各种跳转 =====
    fseek(fp, 0, SEEK_SET);  // 跳到开头
    printf("SEEK_SET 后: %ld\n", ftell(fp));  // 输出: 0

    fseek(fp, 7, SEEK_SET);  // 跳到第 7 个字节
    printf("跳到第7字节后: %ld\n", ftell(fp));  // 输出: 7

    fseek(fp, -1, SEEK_END);  // 跳到倒数第 1 个字节
    printf("倒数第1字节: %ld\n", ftell(fp));  // 输出: 12

    fseek(fp, -7, SEEK_CUR);  // 从当前位置后退 7 字节
    printf("后退7字节后: %ld\n", ftell(fp));  // 输出: 5

    // ===== 读取当前指针位置的内容 =====
    rewind(fp);  // 回到开头
    char buffer[20];
    fgets(buffer, sizeof(buffer), fp);
    printf("从头读取: %s\n", buffer);  // 输出: Hello, World!

    fclose(fp);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include <stdio.h>

typedef struct {
    int id;
    char name[50];
    double salary;
} Employee;

int main() {
    FILE *fp = fopen("employees.bin", "wb+");
    if (fp == NULL) return 1;

    // 写入 3 个员工记录
    Employee e1 = {1, "张三", 5000.0};
    Employee e2 = {2, "李四", 6000.0};
    Employee e3 = {3, "王五", 7000.0};

    fwrite(&e1, sizeof(Employee), 1, fp);
    fwrite(&e2, sizeof(Employee), 1, fp);
    fwrite(&e3, sizeof(Employee), 1, fp);

    // 读取第 2 个员工（索引 1）
    long pos = 1 * sizeof(Employee);
    fseek(fp, pos, SEEK_SET);
    Employee emp;
    fread(&emp, sizeof(Employee), 1, fp);
    printf("第2个员工: ID=%d, 姓名=%s, 薪资=%.2f\n",
           emp.id, emp.name, emp.salary);
    // 输出: 第2个员工: ID=2, 姓名=李四, 薪资=6000.00

    // 修改第 3 个员工的薪资（涨薪 10%）
    pos = 2 * sizeof(Employee);
    fseek(fp, pos, SEEK_SET);
    Employee *emp_ptr = &emp;
    fread(emp_ptr, sizeof(Employee), 1, fp);
    emp.salary *= 1.1;
    fseek(fp, pos, SEEK_SET);  // 重新定位到该记录
    fwrite(&emp, sizeof(Employee), 1, fp);

    fclose(fp);
    return 0;
}

1
2
3
4

#include <stdio.h>

int fgetpos(FILE *stream, fpos_t *pos);
int fsetpos(FILE *stream, const fpos_t *pos);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdio.h>

int main() {
    // ===== 小文件（用 ftell） =====
    FILE *fp1 = fopen("small.bin", "rb");
    if (fp1 == NULL) return 1;
    long pos1 = ftell(fp1);
    printf("当前位置: %ld\n", pos1);
    fclose(fp1);

    // ===== 大文件（用 fgetpos/fsetpos） =====
    FILE *fp2 = fopen("large.bin", "rb");
    if (fp2 == NULL) return 1;

    fpos_t pos2;
    fgetpos(fp2, &pos2);  // 获取当前位置
    printf("当前位置: %lld\n", (long long)pos2);

    // 跳转到文件中间的某个位置（假设很大）
    // pos2.__pos = 5000000000;  // 5GB 位置
    // pos2.__mbstate = 0;
    // fsetpos(fp2, &pos2);

    fclose(fp2);
    return 0;
}

1
2
3

#include <stdio.h>

int fflush(FILE *stream);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>

int main() {
    printf("正在保存数据...");  // 没有换行，缓冲区不刷新

    FILE *fp = fopen("data.txt", "w");
    if (fp == NULL) return 1;

    fprintf(fp, "重要数据：42");
    fflush(fp);  // 强制立刻写入磁盘！

    // 假设这里突然断电...
    // 没有 fflush，数据可能还在缓冲区，就没了！

    fclose(fp);
    printf("保存完成！\n");

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <stdio.h>

int main() {
    // 在 MSVC 上有效，但不可移植
    // fflush(stdin);  // 清空输入缓冲区

    // 跨平台的方法：读取并丢弃
    int c;
    while ((c = getchar()) != '\n' && c != EOF) { }
    // 或者
    // scanf("%*[^\n]");  // 跳过到换行符
    // scanf("%*c");       // 吃掉换行符

    return 0;
}

1
2
3

#include <stdio.h>

FILE *tmpfile(void);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>

int main() {
    FILE *tmp = tmpfile();
    if (tmp == NULL) {
        perror("创建临时文件失败");
        return 1;
    }

    // 写入一些数据
    fprintf(tmp, "这是临时文件的内容\n");
    fprintf(tmp, "程序结束后会自动删除\n");

    // 读取回来验证
    rewind(tmp);
    char buffer[100];
    while (fgets(buffer, sizeof(buffer), tmp) != NULL) {
        printf("%s", buffer);
    }

    fclose(tmp);  // 关闭时自动删除！
    printf("\n临时文件已关闭并删除。\n");

    return 0;
}

1
2
3

#include <stdlib.h>

int mkstemp(char *template);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    // ===== tmpfile（简单但不灵活） =====
    FILE *tmp1 = tmpfile();
    if (tmp1 == NULL) {
        perror("tmpfile 失败");
        return 1;
    }
    printf("tmpfile 创建成功\n");
    fclose(tmp1);  // 自动删除

    // ===== mkstemp（更安全更灵活） =====
    char template[] = "/tmp/myapp_XXXXXX";  // 必须是可以修改的数组！
    int fd = mkstemp(template);
    if (fd == -1) {
        perror("mkstemp 失败");
        return 1;
    }
    printf("临时文件创建成功: %s\n", template);
    printf("文件描述符: %d\n", fd);

    // 使用 fdopen 转换成 FILE *
    FILE *tmp2 = fdopen(fd, "w+");
    if (tmp2 == NULL) {
        perror("fdopen 失败");
        close(fd);  // 注意：如果 fdopen 失败，还是要手动 close
        return 1;
    }

    fprintf(tmp2, "Hello from mkstemp!\n");
    rewind(tmp2);

    char buf[100];
    fgets(buf, sizeof(buf), tmp2);
    printf("读取: %s", buf);

    fclose(tmp2);  // 会同时关闭 fd

    // 手动删除文件（因为 mkstemp 不会自动删除）
    // unlink(template);  // 删除文件名，但文件内容还能访问直到关闭
    printf("临时文件路径: %s\n", template);

    return 0;
}

1
2
3

#include <stdio.h>

FILE *freopen(const char *filename, const char *mode, FILE *stream);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>

int main() {
    // ===== 默认输出到屏幕 =====
    printf("这条消息显示在屏幕上\n");

    // ===== 重定向 stdout 到文件 =====
    FILE *fp = freopen("output.txt", "w", stdout);
    if (fp == NULL) {
        perror("重定向失败");
        return 1;
    }

    // 现在所有 stdout 的输出都会写到 output.txt
    printf("这条消息写入文件！\n");
    printf("这条也是！\n");

    // 恢复 stdout 到屏幕
    fp = freopen("/dev/tty", "w", stdout);  // Linux/macOS
    // fp = freopen("CON", "w", stdout);  // Windows

    printf("这条消息又回到屏幕上了！\n");

    return 0;
}

1
2
3
4
5
6
7

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>

errno_t freopen_s(FILE * restrict * restrict newstream,
                  const char * restrict filename,
                  const char * restrict mode,
                  FILE * restrict stream);

1
2
3

#include <stdio.h>

int rename(const char *old, const char *new);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <stdio.h>

int main() {
    // 先创建一个测试文件
    FILE *fp = fopen("old_name.txt", "w");
    if (fp == NULL) return 1;
    fprintf(fp, "测试内容\n");
    fclose(fp);

    // 重命名
    if (rename("old_name.txt", "new_name.txt") == 0) {
        printf("重命名成功！\n");
    } else {
        perror("重命名失败");
    }

    // 移动文件到其他目录（如果目录存在）
    // rename("new_name.txt", "/tmp/new_name.txt");

    // 验证
    fp = fopen("new_name.txt", "r");
    if (fp != NULL) {
        char buffer[100];
        fgets(buffer, sizeof(buffer), fp);
        printf("文件内容: %s", buffer);
        fclose(fp);
    }

    return 0;
}

1
2
3

#include <stdio.h>

int remove(const char *filename);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stdio.h>

int main() {
    // 删除之前先创建个文件
    FILE *fp = fopen("to_delete.txt", "w");
    if (fp == NULL) return 1;
    fprintf(fp, "即将被删除...\n");
    fclose(fp);

    // 删除
    if (remove("to_delete.txt") == 0) {
        printf("文件删除成功！\n");
    } else {
        perror("删除失败");
    }

    // 验证
    if (fopen("to_delete.txt", "r") == NULL) {
        printf("确认：文件已不存在\n");
    }

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stdio.h>

int main() {
    // ===== 文本模式：换行符会被转换 =====
    FILE *fp = fopen("text_mode.txt", "w");
    if (fp == NULL) return 1;
    fprintf(fp, "Line 1\nLine 2\n");
    fclose(fp);

    // 文本模式下，"\n" 在 Windows 上实际存储为 "\r\n"
    // 所以文件大小是 17 字节，不是 15 字节

    // ===== 二进制模式：不做转换 =====
    fp = fopen("binary_mode.bin", "wb");
    if (fp == NULL) return 1;
    fprintf(fp, "Line 1\nLine 2\n");  // 完全一样的代码
    fclose(fp);

    // 二进制模式下，"\n" 就是 "\n"
    // 文件大小是 15 字节

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdio.h>

int main() {
    // 在 Windows 上创建的文本文件
    FILE *fp = fopen("windows_text.txt", "r");  // 假设文件有 "\r\n"
    char buffer[100];

    // 用 fgets 读取一行
    fgets(buffer, sizeof(buffer), fp);

    // 在 Windows 上，fgets 会自动把 "\r\n" 转换成 "\n"
    // 所以 buffer 里只有 "\n"，没有 "\r"

    // 但如果你用 fgetc 逐字符读：
    int ch1 = fgetc(fp);  // 读到 'L'
    int ch2 = fgetc(fp);  // 读到 'i'
    // ...
    // int ch6 = fgetc(fp);  // 读到 '\r'
    // int ch7 = fgetc(fp);  // 读到 '\n'

    // 你需要自己处理 '\r' 的情况，否则每行末尾会多一个 '\r'
    // 在 Linux 上打开 Windows 文件，行尾会显示 ^M

    fclose(fp);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <stdio.h>

int main() {
#ifdef _WIN32
    printf("Windows 系统，换行符是 \\r\\n\n");
#elif defined(__linux__)
    printf("Linux 系统，换行符是 \\n\n");
#elif defined(__APPLE__)
    printf("macOS 系统，换行符是 \\n\n");
#else
    printf("未知系统\n");
#endif
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#define _FILE_OFFSET_BITS 64  // 必须在 #include 之前！

#include <stdio.h>
#include <sys/types.h>

int main() {
    FILE *fp = fopen("large_file.bin", "rb+");
    if (fp == NULL) {
        perror("打开大文件失败");
        return 1;
    }

    // 现在 fseek/ftell 可以处理 64 位偏移了
    off_t size;
    fseek(fp, 0, SEEK_END);
    size = ftell(fp);
    printf("文件大小: %lld 字节\n", (long long)size);

    // 跳转到 5GB 的位置
    off_t pos = (off_t)5 * 1024 * 1024 * 1024;  // 5GB
    if (fseek(fp, pos, SEEK_SET) == 0) {
        printf("成功跳转到 5GB 位置\n");
    } else {
        printf("跳转失败（可能是文件系统不支持）\n");
    }

    fclose(fp);
    return 0;
}

1

gcc -D_FILE_OFFSET_BITS=64 -o myprogram myprogram.c

1
2

printf("%s %d %s %d\n", "第一", 1, "第二", 2);
// 输出: 第一 1 第二 2

1
2

printf("%2$d %1$d %4$d %3$d\n", 10, 20, 30, 40);
// 输出: 20 10 40 30

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>

int main() {
    // ===== 基本用法 =====
    printf("%2$d %1$d\n", 100, 200);  // 输出: 200 100

    // ===== 位置参数 + 宽度 =====
    printf("%2$5d %1$5d\n", 42, 99);  // 输出: "   99" 和 "   42"
    //     %2$5d  -> 第2个参数，宽度5
    //     %1$5d  -> 第1个参数，宽度5

    // ===== 位置参数 + 精度 =====
    printf("%2$.2f %1$.3f\n", 3.14159, 2.71828);
    // 输出: 2.72 3.142

    // ===== 混用普通和位置参数（C23 标准支持）=====
    printf("%s %2$d %s\n", "hello", 123, "world");
    // 输出: hello 123 world
    // %s 用第1个参数(hello)，%2$d 用第2个参数(123)，%s 用第3个参数(world)

    // ===== 鸡兔同笼问题：位置参数的实用场景 =====
    int heads = 35, legs = 94;
    int chickens = (4 * heads - legs) / 2;
    int rabbits = heads - chickens;
    printf("有 %1$d 只鸡和 %2$d 只兔子\n", chickens, rabbits);
    printf("验证: 头=%1$d+%2$d=%3$d, 腿=%4$d*%1$d+%5$d*%2$d=%6$d\n",
           chickens, rabbits, heads,
           2, 2, rabbits, legs);
    // 输出会很复杂，但展示了位置参数的灵活性

    return 0;
}