C语言对于文件读取和写入

在C语言中，文件的读取和写入是通过标准输入输出库（stdio.h）提供的一系列函数来实现的。这些函数允许程序与文件系统交互，执行诸如打开、关闭、读取、写入和定位文件指针等操作。理解和正确使用这些函数对于开发需要持久化数据的应用程序至关重要。

本文将详细介绍C语言中关于文件读取和写入的完整操作，包括以下内容：

文件I/O基础
文件打开与关闭
读取文件内容
- 字符读取
- 字符串读取
- 格式化读取
- 缓冲读取
写入文件内容
- 字符写入
- 字符串写入
- 格式化写入
- 缓冲写入
文件定位
错误处理
文本文件与二进制文件
高级文件操作
- 文件指针的移动
- 文件长度获取
- 临时文件创建
示例程序
- 读取文件内容
- 写入文件内容
- 复制文件
最佳实践
总结

1. 文件I/O基础

文件I/O（输入/输出）允许程序与存储在磁盘上的文件进行交互。C语言通过FILE类型和一系列标准库函数提供文件操作的支持。

`FILE`类型

FILE是一个结构体，用于存储与文件相关的信息，如文件描述符、缓冲区、当前文件指针位置等。
通过指针（如FILE *fp）来操作文件。

标准文件流

C语言预定义了三个标准文件流：

标准输入（stdin）：默认指向键盘，通常用于读取输入。
标准输出（stdout）：默认指向屏幕，通常用于输出。
标准错误（stderr）：默认指向屏幕，用于输出错误信息。

这些标准流在程序启动时自动打开，无需显式打开和关闭。

2. 文件打开与关闭

在进行文件操作前，必须先打开文件，操作完成后关闭文件。

打开文件：`fopen`

函数原型：

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

filename：要打开的文件名，可以是相对路径或绝对路径。
mode：文件打开模式，决定文件的读写权限和操作类型。

常用的打开模式包括：

模式	描述
`"r"`	以只读方式打开文件，文件必须存在。
`"w"`	以只写方式打开文件，若文件存在则截断为空，若不存在则创建。
`"a"`	以追加方式打开文件，写入时数据将添加到文件末尾，若文件不存在则创建。
`"r+"`	以读写方式打开文件，文件必须存在。
`"w+"`	以读写方式打开文件，若文件存在则截断为空，若不存在则创建。
`"a+"`	以读写方式打开文件，写入时数据将添加到文件末尾，若文件不存在则创建。
`"rb"`	以二进制只读方式打开文件。
`"wb"`	以二进制只写方式打开文件。
`"ab"`	以二进制追加方式打开文件。
`"rb+"`	以二进制读写方式打开文件。
`"wb+"`	以二进制读写方式打开文件。
`"ab+"`	以二进制读写追加方式打开文件。

示例：

#include <stdio.h>

int main() {
    FILE *fp;

    // 以只读方式打开文件
    fp = fopen("example.txt", "r");
    if (fp == NULL) {
        perror("无法打开文件");
        return 1;
    }

    // 文件操作...

    // 关闭文件
    fclose(fp);
    return 0;
}

关闭文件：`fclose`

函数原型：

int fclose(FILE *stream);

stream：指向要关闭的文件的FILE指针。
返回值：成功关闭返回0，失败返回EOF（通常为-1）。

示例：

if (fclose(fp) != 0) {
    perror("无法关闭文件");
}

3. 读取文件内容

C语言提供了多种读取文件内容的方式，适用于不同的数据类型和需求。

3.1 字符读取：`fgetc` 和 `getc`

函数原型：

int fgetc(FILE *stream);
int getc(FILE *stream);

功能：从文件中读取一个字符，并返回该字符的int值。遇到文件结束时返回EOF。
区别：fgetc是函数，getc可能是宏。通常使用fgetc更安全。

示例：

#include <stdio.h>

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

    int c;
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }

    fclose(fp);
    return 0;
}

3.2 字符串读取：`fgets`

函数原型：

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

功能：从文件中读取一行字符串（最多n-1个字符），并将其存储在str中。读取到换行符或文件结束时停止，并在末尾添加'\0'。
返回值：成功读取返回str，失败返回NULL。

示例：

#include <stdio.h>

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

    char buffer[100];
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("%s", buffer);
    }

    fclose(fp);
    return 0;
}

3.3 格式化读取：`fscanf`

函数原型：

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

功能：按照指定的格式从文件中读取数据，并存储到相应的变量中。
返回值：成功读取的项数，遇到文件结束或错误时返回EOF。

示例：

假设data.txt内容如下：

John 25
Jane 30

读取姓名和年龄：

#include <stdio.h>

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

    char name[50];
    int age;
    while (fscanf(fp, "%s %d", name, &age) == 2) {
        printf("姓名: %s, 年龄: %d\n", name, age);
    }

    fclose(fp);
    return 0;
}

3.4 缓冲读取：`fread`

函数原型：

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

功能：从文件中读取nmemb个元素，每个元素大小为size字节，并存储到ptr指向的内存区域。
返回值：成功读取的元素数量。
用途：适用于读取二进制数据或大块数据。

示例：

读取二进制文件：

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

int main() {
    FILE *fp = fopen("binary.dat", "rb");
    if (fp == NULL) {
        perror("无法打开文件");
        return 1;
    }

    // 假设文件中存储了一系列整数
    int buffer[10];
    size_t elements_read = fread(buffer, sizeof(int), 10, fp);
    if (elements_read < 10) {
        if (feof(fp)) {
            printf("已到达文件末尾。\n");
        }
        if (ferror(fp)) {
            perror("读取文件时出错");
        }
    }

    for (size_t i = 0; i < elements_read; i++) {
        printf("整数 %zu: %d\n", i, buffer[i]);
    }

    fclose(fp);
    return 0;
}

4. 写入文件内容

C语言提供了多种向文件写入内容的方式，适用于不同的数据类型和需求。

4.1 字符写入：`fputc` 和 `putc`

函数原型：

int fputc(int char, FILE *stream);
int putc(int char, FILE *stream);

功能：向文件中写入一个字符，并返回该字符的int值。写入失败时返回EOF。
区别：fputc是函数，putc可能是宏。通常使用fputc更安全。

示例：

#include <stdio.h>

int main() {
    FILE *fp = fopen("output.txt", "w");
    if (fp == NULL) {
        perror("无法打开文件");
        return 1;
    }

    char c = 'A';
    if (fputc(c, fp) == EOF) {
        perror("写入字符失败");
    }

    fclose(fp);
    return 0;
}

4.2 字符串写入：`fputs` 和 `puts`

函数原型：

int fputs(const char *str, FILE *stream);
int puts(const char *str);

功能：
- fputs：将字符串写入指定文件，不自动添加换行符。
- puts：将字符串写入标准输出，并在末尾自动添加换行符。
返回值：成功写入返回非负值，失败返回EOF。

示例：

#include <stdio.h>

int main() {
    FILE *fp = fopen("output.txt", "w");
    if (fp == NULL) {
        perror("无法打开文件");
        return 1;
    }

    const char *message = "Hello, World!";
    if (fputs(message, fp) == EOF) {
        perror("写入字符串失败");
    }

    fclose(fp);
    return 0;
}

4.3 格式化写入：`fprintf`

函数原型：

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

功能：按照指定的格式将数据写入文件。
返回值：成功写入的字符数，失败返回负值。

示例：

#include <stdio.h>

int main() {
    FILE *fp = fopen("output.txt", "w");
    if (fp == NULL) {
        perror("无法打开文件");
        return 1;
    }

    const char *name = "Alice";
    int age = 30;
    if (fprintf(fp, "姓名: %s, 年龄: %d\n", name, age) < 0) {
        perror("写入格式化字符串失败");
    }

    fclose(fp);
    return 0;
}

4.4 缓冲写入：`fwrite`

函数原型：

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

功能：向文件中写入nmemb个元素，每个元素大小为size字节，从ptr指向的内存区域复制数据到文件。
返回值：成功写入的元素数量。
用途：适用于写入二进制数据或大块数据。

示例：

写入二进制文件：

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

int main() {
    FILE *fp = fopen("binary.dat", "wb");
    if (fp == NULL) {
        perror("无法打开文件");
        return 1;
    }

    // 假设要写入一系列整数
    int data[] = {1, 2, 3, 4, 5};
    size_t elements_written = fwrite(data, sizeof(int), 5, fp);
    if (elements_written < 5) {
        perror("写入文件时出错");
    }

    fclose(fp);
    return 0;
}

5. 文件定位

文件定位涉及到在文件中移动文件指针的位置，以便进行读写操作。C语言提供了几个函数来实现文件定位。

5.1 `fseek`

函数原型：

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

功能：移动文件指针到指定位置。
参数：
- stream：文件指针。
- offset：相对于whence的偏移量。
- whence：定位的参考点，常用值：
  - SEEK_SET：文件开头。
  - SEEK_CUR：当前位置。
  - SEEK_END：文件末尾。
返回值：成功返回0，失败返回非零值。

示例：

#include <stdio.h>

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

    // 移动文件指针到第10个字节
    if (fseek(fp, 10, SEEK_SET) != 0) {
        perror("fseek失败");
    }

    // 读取并打印下一个字符
    int c = fgetc(fp);
    if (c != EOF) {
        printf("第10个字节的字符: %c\n", c);
    }

    fclose(fp);
    return 0;
}

5.2 `ftell`

函数原型：

long ftell(FILE *stream);

功能：返回当前文件指针的位置，以字节为单位。
返回值：当前文件指针的位置，失败返回-1L。

示例：

#include <stdio.h>

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

    // 读取几个字符
    fgetc(fp);
    fgetc(fp);
    fgetc(fp);

    // 获取当前文件指针位置
    long pos = ftell(fp);
    if (pos == -1L) {
        perror("ftell失败");
    } else {
        printf("当前文件位置: %ld\n", pos);
    }

    fclose(fp);
    return 0;
}

5.3 `rewind`

函数原型：

void rewind(FILE *stream);

功能：将文件指针移动到文件开头，并清除错误和文件结束标志。
返回值：无返回值。

示例：

#include <stdio.h>

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

    // 读取文件直到EOF
    while (fgetc(fp) != EOF);

    // 重新定位到文件开头
    rewind(fp);

    // 再次读取文件
    int c;
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }

    fclose(fp);
    return 0;
}

6. 错误处理

在文件操作中，错误处理是确保程序健壮性和可靠性的关键。C语言提供了一些机制来检测和处理错误。

6.1 检查文件是否成功打开

在调用fopen后，应立即检查返回的FILE指针是否为NULL，以确定文件是否成功打开。

示例：

FILE *fp = fopen("example.txt", "r");
if (fp == NULL) {
    perror("无法打开文件");
    // 处理错误，如退出程序或提示用户
}

6.2 检查读写操作的返回值

所有文件读写函数都会返回状态值，表示操作是否成功。应根据这些返回值进行相应的错误处理。

读取函数：
- fgetc：返回EOF表示文件结束或错误。
- fgets：返回NULL表示文件结束或错误。
- fread：返回实际读取的元素数量，若小于预期则可能是文件结束或错误。
写入函数：
- fputc、fputs、fprintf、fwrite：返回值表明是否成功。

示例：

// 读取文件
int c = fgetc(fp);
if (c == EOF) {
    if (feof(fp)) {
        printf("已到达文件末尾。\n");
    }
    if (ferror(fp)) {
        perror("读取文件时出错");
    }
}

// 写入文件
if (fputs("Hello, World!\n", fp) == EOF) {
    perror("写入文件时出错");
}

6.3 清除错误标志：`clearerr`

如果在文件操作过程中发生错误，文件流会设置错误标志。可以使用clearerr函数清除这些标志，恢复文件流状态。

函数原型：

void clearerr(FILE *stream);

示例：

if (fgetc(fp) == EOF) {
    if (ferror(fp)) {
        perror("读取文件时出错");
        clearerr(fp);
    }
}

6.4 使用`errno`

标准库函数在出错时通常会设置全局变量errno，指示具体的错误原因。可以使用perror或strerror来获取错误信息。

示例：

#include <errno.h>
#include <string.h>

FILE *fp = fopen("nonexistent.txt", "r");
if (fp == NULL) {
    printf("打开文件时出错: %s\n", strerror(errno));
}

7. 文本文件与二进制文件

C语言中，文件可以分为文本文件和二进制文件。它们在读取和写入时有一些区别，尤其是在处理换行符和数据表示时。

7.1 文本文件

特点：
- 以字符为单位进行读写。
- 特殊字符（如换行符）可能会被转换以适应不同操作系统的表示方式（如Windows的\r\n，Unix/Linux的\n）。
打开模式：如"r"、"w"、"a"等。

7.2 二进制文件

特点：
- 以字节为单位进行读写，不进行任何转换。
- 适用于非文本数据，如图像、音频、视频、可执行文件等。
打开模式：如"rb"、"wb"、"ab"等。

注意：在文本模式下，某些字符可能会被转换（如\n转为\r\n），而在二进制模式下不会进行任何转换。

示例：

// 文本模式读取
FILE *fp = fopen("text.txt", "r");

// 二进制模式读取
FILE *fp_bin = fopen("image.png", "rb");

8. 高级文件操作

除了基本的读写操作，C语言还提供了一些高级的文件操作函数，增强了文件处理的灵活性和功能。

8.1 文件指针的移动

fseek：移动文件指针到指定位置。
ftell：获取当前文件指针的位置。
rewind：将文件指针移动到文件开头，并清除错误和EOF标志。

8.2 文件长度获取

通过fseek和ftell结合使用，可以获取文件的长度。

示例：

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

long get_file_size(FILE *fp) {
    if (fseek(fp, 0, SEEK_END) != 0) {
        perror("fseek失败");
        return -1;
    }
    long size = ftell(fp);
    if (size == -1L) {
        perror("ftell失败");
    }
    rewind(fp); // 将文件指针恢复到开头
    return size;
}

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

    long size = get_file_size(fp);
    if (size != -1L) {
        printf("文件大小: %ld 字节\n", size);
    }

    fclose(fp);
    return 0;
}

8.3 临时文件创建：`tmpfile` 和 `tmpnam`

8.3.1 `tmpfile`

函数原型：

FILE *tmpfile(void);

功能：创建一个临时文件，文件在关闭时自动删除。
返回值：成功时返回FILE指针，失败时返回NULL。

示例：

#include <stdio.h>

int main() {
    FILE *tmp = tmpfile();
    if (tmp == NULL) {
        perror("tmpfile失败");
        return 1;
    }

    fprintf(tmp, "临时数据\n");

    rewind(tmp);
    char buffer[50];
    if (fgets(buffer, sizeof(buffer), tmp) != NULL) {
        printf("从临时文件读取: %s", buffer);
    }

    fclose(tmp); // 临时文件被自动删除
    return 0;
}

8.3.2 `tmpnam`

函数原型：

char *tmpnam(char *str);

功能：生成一个唯一的临时文件名。
返回值：成功时返回临时文件名的指针，失败时返回NULL。

注意：tmpnam可能存在安全风险，因为生成的文件名可能会被其他进程使用，建议使用更安全的函数如mkstemp。

示例：

#include <stdio.h>

int main() {
    char filename[L_tmpnam];
    if (tmpnam(filename) == NULL) {
        perror("tmpnam失败");
        return 1;
    }

    printf("临时文件名: %s\n", filename);

    FILE *fp = fopen(filename, "w");
    if (fp == NULL) {
        perror("无法创建临时文件");
        return 1;
    }

    fprintf(fp, "临时数据\n");
    fclose(fp);

    // 删除临时文件
    if (remove(filename) != 0) {
        perror("无法删除临时文件");
    }

    return 0;
}

8.4 文件缓冲管理

C语言的文件I/O是基于缓冲区的，默认情况下会使用全缓冲、行缓冲或无缓冲。

全缓冲：数据被存储在缓冲区中，直到缓冲区满或调用fflush/fclose时才写入文件。
行缓冲：数据在遇到换行符时自动刷新缓冲区。
无缓冲：数据立即写入文件。

使用setvbuf函数可以控制文件流的缓冲行为。

函数原型：

int setvbuf(FILE *stream, char *buffer, int mode, size_t size);

参数：
- stream：文件指针。
- buffer：用户提供的缓冲区，如果为NULL则由系统分配。
- mode：缓冲模式，_IOFBF（全缓冲）、_IOLBF（行缓冲）、_IONBF（无缓冲）。
- size：缓冲区大小。

示例：

#include <stdio.h>

int main() {
    FILE *fp = fopen("output.txt", "w");
    if (fp == NULL) {
        perror("无法打开文件");
        return 1;
    }

    // 设置为无缓冲
    if (setvbuf(fp, NULL, _IONBF, 0) != 0) {
        perror("setvbuf失败");
    }

    // 写入数据，立即写入文件
    fputc('A', fp);
    fputc('B', fp);

    fclose(fp);
    return 0;
}

8.5 文件权限和模式

在fopen时指定的模式不仅决定了文件的读写权限，还影响文件的创建和截断行为。了解不同模式的含义对于正确管理文件至关重要。

常用模式复习：

模式	描述
`"r"`	只读，文件必须存在。
`"w"`	只写，若文件存在则截断为空，若不存在则创建。
`"a"`	追加写入，数据添加到文件末尾，若文件不存在则创建。
`"r+"`	读写，文件必须存在。
`"w+"`	读写，若文件存在则截断为空，若不存在则创建。
`"a+"`	读写，写入时追加，若文件不存在则创建。
`"rb"`	二进制只读，文件必须存在。
`"wb"`	二进制只写，若文件存在则截断为空，若不存在则创建。
`"ab"`	二进制追加写入，若文件不存在则创建。
`"rb+"`	二进制读写，文件必须存在。
`"wb+"`	二进制读写，若文件存在则截断为空，若不存在则创建。
`"ab+"`	二进制读写追加，若文件不存在则创建。

9. 示例程序

通过以下几个示例，展示如何在C语言中进行文件的读取和写入操作。

9.1 读取文件内容

示例1：逐字符读取并打印文件内容。

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

int main() {
    FILE *fp = fopen("example.txt", "r");
    if (fp == NULL) {
        perror("无法打开文件");
        return EXIT_FAILURE;
    }

    int c;
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }

    if (ferror(fp)) {
        perror("读取文件时出错");
    }

    fclose(fp);
    return EXIT_SUCCESS;
}

示例2：逐行读取并打印文件内容。

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

int main() {
    FILE *fp = fopen("example.txt", "r");
    if (fp == NULL) {
        perror("无法打开文件");
        return EXIT_FAILURE;
    }

    char buffer[256];
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("%s", buffer);
    }

    if (ferror(fp)) {
        perror("读取文件时出错");
    }

    fclose(fp);
    return EXIT_SUCCESS;
}

示例3：读取格式化数据。

假设data.txt内容如下：

Alice 25
Bob 30
Charlie 22

读取姓名和年龄并打印：

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

int main() {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) {
        perror("无法打开文件");
        return EXIT_FAILURE;
    }

    char name[50];
    int age;
    while (fscanf(fp, "%s %d", name, &age) == 2) {
        printf("姓名: %s, 年龄: %d\n", name, age);
    }

    if (ferror(fp)) {
        perror("读取文件时出错");
    }

    fclose(fp);
    return EXIT_SUCCESS;
}

示例4：读取二进制文件。

假设有一个包含整数的二进制文件numbers.bin：

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

int main() {
    FILE *fp = fopen("numbers.bin", "rb");
    if (fp == NULL) {
        perror("无法打开文件");
        return EXIT_FAILURE;
    }

    int buffer[5];
    size_t elements_read = fread(buffer, sizeof(int), 5, fp);
    if (elements_read < 5) {
        if (feof(fp)) {
            printf("已到达文件末尾。\n");
        }
        if (ferror(fp)) {
            perror("读取文件时出错");
        }
    }

    for (size_t i = 0; i < elements_read; i++) {
        printf("数字 %zu: %d\n", i + 1, buffer[i]);
    }

    fclose(fp);
    return EXIT_SUCCESS;
}

9.2 写入文件内容

示例1：逐字符写入文件。

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

int main() {
    FILE *fp = fopen("output_char.txt", "w");
    if (fp == NULL) {
        perror("无法打开文件");
        return EXIT_FAILURE;
    }

    char str[] = "Hello, World!\n";
    for (int i = 0; str[i] != '\0'; i++) {
        if (fputc(str[i], fp) == EOF) {
            perror("写入字符失败");
            fclose(fp);
            return EXIT_FAILURE;
        }
    }

    fclose(fp);
    return EXIT_SUCCESS;
}

示例2：逐行写入文件。

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

int main() {
    FILE *fp = fopen("output_line.txt", "w");
    if (fp == NULL) {
        perror("无法打开文件");
        return EXIT_FAILURE;
    }

    const char *lines[] = {
        "第一行。\n",
        "第二行。\n",
        "第三行。\n"
    };

    for (int i = 0; i < 3; i++) {
        if (fputs(lines[i], fp) == EOF) {
            perror("写入字符串失败");
            fclose(fp);
            return EXIT_FAILURE;
        }
    }

    fclose(fp);
    return EXIT_SUCCESS;
}

示例3：格式化写入文件。

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

int main() {
    FILE *fp = fopen("output_format.txt", "w");
    if (fp == NULL) {
        perror("无法打开文件");
        return EXIT_FAILURE;
    }

    const char *names[] = {"Alice", "Bob", "Charlie"};
    int ages[] = {25, 30, 22};

    for (int i = 0; i < 3; i++) {
        if (fprintf(fp, "姓名: %s, 年龄: %d\n", names[i], ages[i]) < 0) {
            perror("写入格式化字符串失败");
            fclose(fp);
            return EXIT_FAILURE;
        }
    }

    fclose(fp);
    return EXIT_SUCCESS;
}

示例4：写入二进制文件。

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

int main() {
    FILE *fp = fopen("numbers.bin", "wb");
    if (fp == NULL) {
        perror("无法打开文件");
        return EXIT_FAILURE;
    }

    int numbers[] = {10, 20, 30, 40, 50};
    size_t elements_written = fwrite(numbers, sizeof(int), 5, fp);
    if (elements_written < 5) {
        perror("写入文件时出错");
    }

    fclose(fp);
    return EXIT_SUCCESS;
}

9.3 复制文件

以下示例展示如何将一个文件的内容复制到另一个文件中。

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

#define BUFFER_SIZE 1024

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "用法: %s <源文件> <目标文件>\n", argv[0]);
        return EXIT_FAILURE;
    }

    // 打开源文件
    FILE *src = fopen(argv[1], "rb");
    if (src == NULL) {
        perror("无法打开源文件");
        return EXIT_FAILURE;
    }

    // 打开目标文件
    FILE *dest = fopen(argv[2], "wb");
    if (dest == NULL) {
        perror("无法打开目标文件");
        fclose(src);
        return EXIT_FAILURE;
    }

    // 复制内容
    char buffer[BUFFER_SIZE];
    size_t bytes;
    while ((bytes = fread(buffer, 1, BUFFER_SIZE, src)) > 0) {
        if (fwrite(buffer, 1, bytes, dest) != bytes) {
            perror("写入目标文件时出错");
            fclose(src);
            fclose(dest);
            return EXIT_FAILURE;
        }
    }

    if (ferror(src)) {
        perror("读取源文件时出错");
    }

    fclose(src);
    fclose(dest);
    printf("文件复制成功。\n");
    return EXIT_SUCCESS;
}

使用方法：

./copyfile source.txt destination.txt

10. 最佳实践

在进行文件读写操作时，遵循一些最佳实践可以提高代码的可靠性、效率和安全性。

10.1 始终检查函数返回值

所有文件操作函数都可能失败，始终检查返回值以确保操作成功。

示例：

FILE *fp = fopen("file.txt", "r");
if (fp) {
    // 使用文件
} else {
    perror("fopen失败");
}

10.2 使用合适的打开模式

根据需求选择正确的文件打开模式，避免不必要的数据截断或权限问题。

示例：

需要追加数据时使用"a"或"a+"模式。
需要读写文件时使用"r+"、"w+"或"a+"模式。

10.3 释放资源

确保所有打开的文件在使用完毕后关闭，避免资源泄漏。

示例：

FILE *fp = fopen("file.txt", "r");
// 使用文件
fclose(fp);

10.4 使用缓冲

合理利用文件缓冲机制，提高读写效率。对于大量数据的读写，使用fread和fwrite等函数更高效。

10.5 处理二进制和文本文件的区别

在处理二进制文件时，使用二进制模式打开文件，避免数据损坏。

示例：

FILE *fp = fopen("image.png", "rb");
if (fp == NULL) {
    perror("无法打开文件");
}

10.6 使用安全的临时文件创建函数

尽量使用tmpfile而非tmpnam，因为前者更安全，避免命名冲突和安全漏洞。

示例：

FILE *tmp = tmpfile();
if (tmp == NULL) {
    perror("tmpfile失败");
} else {
    // 使用临时文件
    fclose(tmp); // 临时文件自动删除
}

10.7 处理EOF和错误

在读取文件时，正确区分文件结束和读取错误。

示例：

int c = fgetc(fp);
if (c == EOF) {
    if (feof(fp)) {
        printf("已到达文件末尾。\n");
    }
    if (ferror(fp)) {
        perror("读取文件时出错");
    }
}

10.8 使用结构体对齐和填充

确保使用正确的结构体对齐和填充，尤其是在跨平台开发时，考虑使用#pragma pack或手动填充字段。

示例：

#pragma pack(push, 1)
struct Data {
    char id;
    int value;
};
#pragma pack(pop)

10.9 使用适当的缓冲区大小

选择合适的缓冲区大小以优化性能。对于大文件操作，较大的缓冲区通常能提高效率。

示例：

#define BUFFER_SIZE 4096
char buffer[BUFFER_SIZE];

11. 总结

C语言提供了一套强大的文件I/O函数，允许程序与文件系统进行高效且灵活的交互。通过本文的详细讲解，您应该能够掌握以下内容：

文件打开与关闭：使用fopen和fclose管理文件生命周期。
读取文件内容：使用fgetc、fgets、fscanf和fread等函数根据需求读取文件。
写入文件内容：使用fputc、fputs、fprintf和fwrite等函数根据需求写入文件。
文件定位：使用fseek、ftell和rewind管理文件指针的位置。
错误处理：通过检查返回值和使用perror等函数进行错误检测和处理。
文本文件与二进制文件：理解它们的区别，选择合适的模式进行操作。
高级文件操作：如文件长度获取、临时文件创建和缓冲管理等。
最佳实践：包括检查函数返回值、正确使用打开模式、释放资源、使用安全的函数等。

掌握这些知识后，您可以编写出可靠、高效且安全的C语言程序，满足各种文件处理需求。建议在实际项目中多进行练习，并参考相关的C语言编程书籍和资源，进一步深化理解和应用。

附录：参考文献

C Programming Language by Brian W. Kernighan and Dennis M. Ritchie
Advanced Programming in the UNIX Environment by W. Richard Stevens
man pages（如man fopen、man fread等）

如果您在实际应用中遇到更多复杂的问题，建议结合调试工具（如GDB、Valgrind）和网络资源（如Stack Overflow）进行深入学习和问题解决。

分享

C语言对于文件读取和写入

1. 文件I/O基础

FILE类型

标准文件流

2. 文件打开与关闭

打开文件：fopen

关闭文件：fclose

3. 读取文件内容

3.1 字符读取：fgetc 和 getc

3.2 字符串读取：fgets

3.3 格式化读取：fscanf

3.4 缓冲读取：fread

4. 写入文件内容

4.1 字符写入：fputc 和 putc

4.2 字符串写入：fputs 和 puts

4.3 格式化写入：fprintf

4.4 缓冲写入：fwrite

5. 文件定位

5.1 fseek

5.2 ftell

5.3 rewind

6. 错误处理

6.1 检查文件是否成功打开

6.2 检查读写操作的返回值

6.3 清除错误标志：clearerr

6.4 使用errno

7. 文本文件与二进制文件

7.1 文本文件

7.2 二进制文件

8. 高级文件操作

8.1 文件指针的移动

8.2 文件长度获取

8.3 临时文件创建：tmpfile 和 tmpnam

8.3.1 tmpfile

8.3.2 tmpnam

8.4 文件缓冲管理

8.5 文件权限和模式

9. 示例程序

9.1 读取文件内容

9.2 写入文件内容

9.3 复制文件

10. 最佳实践

10.1 始终检查函数返回值

10.2 使用合适的打开模式

10.3 释放资源

10.4 使用缓冲

10.5 处理二进制和文本文件的区别

10.6 使用安全的临时文件创建函数

10.7 处理EOF和错误

10.8 使用结构体对齐和填充

10.9 使用适当的缓冲区大小

11. 总结

附录：参考文献

评论

`FILE`类型

打开文件：`fopen`

关闭文件：`fclose`

3.1 字符读取：`fgetc` 和 `getc`

3.2 字符串读取：`fgets`

3.3 格式化读取：`fscanf`

3.4 缓冲读取：`fread`

4.1 字符写入：`fputc` 和 `putc`

4.2 字符串写入：`fputs` 和 `puts`

4.3 格式化写入：`fprintf`

4.4 缓冲写入：`fwrite`

5.1 `fseek`

5.2 `ftell`

5.3 `rewind`

6.3 清除错误标志：`clearerr`

6.4 使用`errno`

8.3 临时文件创建：`tmpfile` 和 `tmpnam`

8.3.1 `tmpfile`

8.3.2 `tmpnam`